链式存储队列
A. 数据结构队列的链式存储和链式存储
头文件：dynamicArray.h
头文件：seqQueue.h
源文件：
seqQueue.c
源文件：dynamicArray.c
源文件：01队列_顺序存储.c
打印结果：
头文件：LinkQueue.h
源文件：LinkQueue.c
源文件：02队列_链式存储.c
打印结果：
打印结果：
B. 链式队列存储结构的定义及基本操作
链式队列其实很简单的。
其实就是一个链表，不过这个链表你只能从表尾插入，从表头删除。（单向队列）
链表你肯定会吧，定义两个指针，分别指向表头和表尾，作为队头指针和队尾指针。封装起来。
这就是一个链式队列了。
基本操作无非是入队，出队，删除这些，跟基本链表操作一样的。
C. 队列在链式存储上的操作包括:(6) 队列置空操作CLEAR(Q)(7) 求队列中元素个数的操作 CURRENT_SIZE(Q)
#include "stdio.h"
#include "stdlib.h"
#include "z.h"
//链队列初始化
void initlinkqueue(LINKQUEUE *q)
{
q->front=(LINKQLIST *)malloc(sizeof(LINKQLIST));
(q->front)->next=NULL;
q->rear=q->front;
}
//判链队列空
int emptylinkqueue(LINKQUEUE *q)
{
int v;
if(q->front==q->rear)
v=1;
else
v=0;
return v;
}
//读链队列队首元素
DATATYPE1 getlinkfront(LINKQUEUE *q)
{
DATATYPE1 v;
if(emptylinkqueue(q))
v=NULL;
else
v=(q->front)->next->data;
return v;
}
//元素插入链队列
void enlinkqueue(LINKQUEUE *q,DATATYPE1 x)
{
(q->rear)->next=(LINKQLIST *)malloc(sizeof(LINKQLIST));
q->rear=(q->rear)->next;
(q->rear)->data=x;
(q->rear)->next=NULL;
}
//从链队列中删除元素
DATATYPE1 dellinkqueue(LINKQUEUE *q)
{
LINKQLIST *p;
DATATYPE1 v;
if(emptylinkqueue(q))
{ printf("Queue is empty.\n");
v=NULL;}
else
{p=(q->front)->next;
(q->front)->next=p->next;
if(p->next==NULL)
q->rear=q->front;
v=p->data;
free(p);}%0
D. 链式队列是什么
队列分为两种，一种是线性的，另一种为非线性（链式）。前者在计算机中以相邻顺序存放（相当于是一条直线）；后者通俗说是将直线首尾连起来，但存放是以指针方式存入的不是想念存放的。
数据结构的基本问题。队列 是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。一般队列的存储结构是顺序存储，当队列的存储结构是链式存储结构时（即队列中每个元素都包含一个指向其后继的指针，最后一个元素指针为null)，就是链式队列，和链栈同理。
E. 采用链式存储实现队列的初始化、入队、出队操作
#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -2
typedef struct QNode{//创建队成员
int data;//数据成员
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{//队头队尾指针
QueuePtr front;
QueuePtr rear;
}LinkQueue;
void InitQueue(LinkQueue &Q)//初始化队列
{
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));//开辟空间
if(!Q.front) exit ( OVERFLOW);//开辟失败则退出
Q.front ->next = NULL;
//return 1;
}
int EnQueue(LinkQueue &Q)//入队操作
{
int e;
QueuePtr p;
printf("请输入入队元素:");
scanf("%d",&e);
p=(QueuePtr)malloc(sizeof(QNode));
if (p==NULL) exit (OVERFLOW);
p->data = e; p->next = NULL;
Q.rear->next=p;//把p插入队尾
Q.rear=p;//把p变为队尾
return 1;
}
int DeQueue(LinkQueue &Q)//出队操作
{
QueuePtr p;
int e;
if ( Q.front == Q.rear){
printf("队列为空\n");
return -1;
}
p=Q.front->next;//头指针为空
e=p->data;
printf("%d 出对\n",e);
Q.front->next =p->next;//指针后移
if (Q.rear == p) Q.rear = Q.front;//如果p为队尾
free(p);//释放p
return 1;
}
void tip()
{
printf("*************\n");
printf("*输入1 进队 *\n");
printf("*输入2 出对 *\n");
printf("*请选择: *\n");
printf("*************\n");
}
int main()
{
int k;
LinkQueue Q;
InitQueue(Q);//初始化队列
tip();
while(scanf("%d",&k),k)
{
switch(k)
{
case 1:
EnQueue(Q);
tip();
printf("操作完毕\n");
break;
case 2:
DeQueue(Q);
tip();
printf("操作完毕\n");
break;
}
}
return 0;
}
F. 试述队列的链式存储结构和顺序存储结构的优缺点
顺序存储结构是在内存中开辟一个连续的空间用来存储数据,因此对于内存的需求和苛刻,必须是连续的空间.在数据查找(特别是不按照规律排列的数据),时间复杂度教少.效率高.链式存储结构是采取连表指针来指示数据的存储位置,这就可以是在内存中随意的存储,没有必须连续储存空间的要求,对于内存的要求相对教容易.但是要是是从小到大顺序排列的数据,链式存储结构的时间复杂度教小,效率高.但是要是不规则排布的数据一般时间复杂度较高,效率更低G. 如何在链式存储队列多加一个输出队列的最后一个元素
jQuery 选择器中 :last 表示最后一个元素，所以表示含有某类属性的最后一个元素可用如下代码表示
$("test-class:last") // 表示最后一个属于test-class类的元素
示例如下：
创建Html元素
<div class="top">
<ul>
<li>list-1</li>
<li class="selected">list-2</li>
<li class="selected">list-3</li>
<li>list-4</li>
<li class="selected">list-5</li>
</ul>
<span>红色列表项表示属于selected类，弹出框显示了最后一个属于selected类的元素的内容</span>
</div>
设置css样式
div.top{margin:50px;padding:10px;width:300px;height:250px;border:2px dashed #ebbcbe;}
li{padding:5px;}
li.selected{color:red;font-weight:bold;}
span{color:#999;}
编写jquery代码
$(function(){
$("ul").click(function() {
alert($("li.selected:last").text());
});
})
观察显示效果
H. 数据结构链式存储队列中删除元素的算法
给你一个全的吧
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct LNode
{
int Data;
struct LNode *Next;
}LNode;
void CreateList(struct LNode *HeadList,int n,int a[])
{
int i;
struct LNode *p;
HeadList=(struct LNode*)malloc(sizeof(struct LNode));
HeadList->Next=NULL;
for(i=n;i>0;--i)
{
p=(struct LNode*)malloc(sizeof(struct LNode));
p->Data=a[i];
p->Next=HeadList->Next;
HeadList->Next=p;
}
}
void ListInsert(struct LNode *HeadList,int i,int newnode)
{
struct LNode *p=HeadList;
struct LNode *s;
int j=0;
while(p && j<i-1)
{
p=p->Next;
j++;
}
if(!p || j>i-1)
{
cout<<"位置小于1或大于表长";
return;
}
s=(struct LNode*)malloc(sizeof(struct LNode));
s->Data=newnode;
s->Next=p->Next;
p->Next=s;
}
void ListDelete(struct LNode *HeadList,int i)
{
struct LNode *p=HeadList;
struct LNode *s;
int j=0;
while(p->Next && j<i-1)
{
p=p->Next;
++j;
}
if(!(p->Next) || j>i-1)
{
cout<<"删除位置不合理";
return;
}
s=p->Next;
p->Next=s->Next;
int number;
cin>>number;
s->Data=number;
cout<<"被删除的结点是"<<s->Data;
free(s);
}
void ListDisp(struct LNode *HeadList)
{
struct LNode *p;
int i=0;
p=HeadList->Next;
while(p)
{
cout<<p->Data;
++i;
p=p->Next;
}
}
int getoptions()
{
int opt;
cout<<"1: 录入链表"<<endl;
cout<<"2: 显示链表"<<endl;
cout<<"3: 插入结点"<<endl;
cout<<"4: 删除结点"<<endl;
cout<<"5: 退出"<<endl;
cout<<"输入选项并按回车确认:";
cin>>opt;
return opt;
}
int main(int argc,char * argv[])
{
int opt;
int where;
int value;
int count;
int a[5]={2,4,6,8,10};
struct LNode *HeadList;
while(1)
{
opt=getoptions();
if(opt==1)
{
//cout<<"请输入链表的初始结点数";
//cin>>count;
//cout<<"请输入各个结点数值，每输入一个按回车确认";
CreateList(HeadList,5,a);
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==2)
{
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==3)
{
ListDisp(HeadList);
cin>>where;
cout<<"请输入要插入的数值";
cin>>value;
ListInsert(HeadList,where,value);
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==4)
{
ListDisp(HeadList);
cout<<"请输入要删除的位置";
cin>>where;
ListDelete(HeadList,where);
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==5)
{
return 0;
}
}
}
不好意思，我发完之后才看见是队列，乍一看以为是链表，我发的这个是链表的，快下班了，明天上班再给你写一个吧
I. 编写链式存储队列基本操作函数
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
class node{
public:
int data;
node *next;
};
node* create(int len)
{
int c=0,i=1,k=0,flag=-1;
node* l;
node* r;
node* s;
l=(node*)new node;
l->next=NULL;
r=l;
while(i<=len)
{
cout<<"请输入第"<<i<<"个节点值"<<endl;
cin>>c;
s=(node*)new node;
s->data=c;
r->next=s;
r=s;
i++;
}
srand(time(NULL));
flag=rand()%2;
if(flag==0)
{
r->next=NULL;
cout<<"随机无循环"<<endl;
return l;
}
else
{
srand(time(NULL));
k=1+rand()%len;
cout<<"循环到第"<<k<<"个节点"<<endl;
s=l;
for(int j=1;j<=k;j++)
s=s->next;
r->next=s;
return l;
}
}
bool j(node* l,int len)//通过函数判断有无循环
{
for(int i=0;i<len;i++)
l=l->next;
if(l->next==NULL)return 0;
return 1;
}
void main()
{
node* l;
int len=0;
cout<<"请输入链表长度："<<endl;
cin>>len;
l=create(len);
if(j(l,len))cout<<"通过函数判断为有循环"<<endl;
else cout<<"通过函数判断为无循环"<<endl;
}
J. 链式存储队列的数据结构（逻辑结构+存储结构）分析、链式存储队列的基本C语言结构体分析与定义
链式队列
链式存储结构的队列称作链式队列。
链式队列的队头指针指在队列的当前队头结点位置，队尾指针指在队列的当前队尾结点位置。不带头结点的链式队列时可直接删除队头指针所指的结点。
链式队列中结点的结构体可定义如下：
typedef struct qnode
{
DataType datal;
Struct qnode *next;
}LQNode;
为了方便参数调用，通常把链式队列的队头指针front和队尾指针rear也定义为如下的结构体类型LQueue：
typedef struct
{
LQNode *front;
LQNode *rear;
}LQueue;
链式队列操作的实现
（1） 初始化QueueInitiate(LQueue *Q)
void QueueInitiate(LQueue *Q)
{
Q->rear=NULL;
Q->front=NULL;
}
(2)非空否QueueNotEmpty(LQueue Q)
int QueueNotEmpty(LQueue Q)
/*判断链式队列Q非空否，非空返回1，否则返回0*/
{
if(Q.front==NULL)return 0;
else return 1;
}
(3)入队列QueueAppend(LQueue *Q,DataType x)
int QueueAppend(LQueue *Q,DataType x)
/*把数据元素x插入链式队列Q队列的队尾，入队列成功返回1，否则返回0*/
{
LQNode *p;
if((p=(LQNode*)malloc(sizeof(LQNode)))==NULL)
{
printf(“内存不足无法插入!\n);
return 0;
}
p->data=x;
p->next=NULL;
if(Q->rear!=NULL)Q->rear->next=p;
Q->rear=p;
if(Q->front==NULL)Q->front=p;
return 1;
}
(4)出队列QueueDelete(LQueue *Q,DataType *d)
int QueueDelete(LQueue *Q,DataType *d)
/*删除链式队列Q的队头数据元素值到d，出队列成功返回1，否则返回0*/
{
LQNode *p;
if(Q->front==NULL)
{
printf(“队列已空无数据元素出队列!\n”);
return 0;
}
else
{
*d=Q->front->data;
p=Q->front;
Q->front=Q->front->next;
if(Q->front==NULL)Q->rear=NULL;
free(p);
return 1;
}
}
(5)取队头数据元素QueueGet(LQueue *Q,DataType *d)
int QueueGet(LQueue *Q,DataType *d)
/*取链式队列Q的当前队头数据元素值到d，成功返回1，否则返回0*/
{
if(Q.front==NULL)
{
printf(“队列已空无数据元素出队列!\n);
return 0;
}
else
{
*d=Q.front->data;
return 1;
}
}
(6)撤销动态申请空间Destory(LQueue *head)
int Destory(LQueue *head)
{
LQNode *p,*p1;
p=Q.front;
while(p!=NULL)
{
p1=p;
p=p->next;
free(p1);
}
}
帮你转的，我觉得他描述的很清楚。希望对你有帮助。