c学生成绩表用队列表示

Ⅰ C语言链表与队列的问题

首先：链表与队列都是数据结构的一种
一.
链表
1.定义

链表(Linked
list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在由一个个节点组成，每个节点（node）中储存着数据变量（data）和指针变量（node
next），又有一个头节点（head）连接下面的节点，而最后一个节点指向空（null）。可以在链表类中定义增加，删除，插入，遍历，修改等方法，故常用来储存数据。

2.
优点

（1）.使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

（2）.数据的存取往往要在不同的排列顺序中转换，而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。

3.
缺点

链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

4.
类型

主要有单向链表，双向链表以及循环链表。

5.
实例

6.
与数组（Array）的对比

链表的使用不需要知道数据的大小，而数组在创建时必须指明数组的大小。

链表没有对应的下标，只有指向下一个数据的指针，而数组中每一个都有一个相对应的下标。

链表在内存中储存的数据可以是不连续的，而数组储存的数据占内存中连续的一段，用标识符标识。
二.
队列
1.
定义

队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将最后被删除的元素，因此队列又称为“先进先出”（FIFO—first
in
first
out）的线性表。

Ⅱ c语言循环队列

队列是一种特殊的线性表，循环队列是将向量空间想象为一个首尾相接版的圆环。权

队列是一个特殊的线性表，它的特殊之处在于它只允许表的前面的操作删除，而在表的后面的操作插入，就像堆栈一样，队列100是一个线性表，具有有限的操作。

循环队列就是把向量空间想象成一个首尾相连的环，把这样的向量称为循环向量。存储学位的队列称为循环队列。

在顺序队列中，当指向队列末端的指针到达数组的上界时，不能有更多的队列条目，但数组中仍然有一个空位置。这称为“假溢出”。

(2)c学生成绩表用队列表示扩展阅读：

判断满队列状态：

1．计数；你通常使用count

Count等于队列的MAXSIZE

2．国旗int

Queueinflag＝1Queueoutflag＝0

= && flag = = 0的前面和后面

3．放一个存储应答单元为空，不存储数据

后面＋1＝前面

注：（不）顺序结构，SeqQueuemyQueue；

Ⅲ 请高手用C语言链表模拟一个队列 谢谢

#define
MAXSIZE
100
typedef
int
datatype;
typedef
struct{
datatype
a[MAXSIZE];
int
front;
int
rear;
}seqqueue;
/*队列置空*/
void
initseqqueue(seqqueue
*p)
{
p->front=p->rear=0;
}
/*判断队列是否这空*/
int
isemptyseqque(seqqueue
*p)
{
return(p->front==p->rear?1:0);
}
/*输出队列中的元素*/
void
outputseqqueue(seqqueue
*p)
{
int
i;
if(isemptyseqqueue(p)){printf("\nThe
sequece
queue
is
empty\n");exit(1);}
for(i=p->front;i<p->rear;i++)
printf("%5d",p->a[i]);
}
/*取得队列首结点值*/
datatype
getfirstseqqueue(seqqueue
*p)
{
if(isemptyseqqueue(p)){printf("\nThe
sequece
queue
is
empty\n");exit(1);}
return
p->a[p->front];
}
/*给队列插入一个结点*/
void
insertseqqueue(seqqueue
*p)
{
int
i;
if(p->rear==MAXSIZE){printf("\nThe
sequece
queue
is
full\n");exit(1);}
p->a[p->rear]=x;
p->rear++;
}
/*删除队列中的第一个结点*/
void
delseqqueue(seqqueue
*p)
{
if(isemptyseqqueue(p)){printf("\nThe
sequece
queue
is
empty\n");exit(1);}
p->front++;
}
自己再编一下main()函数应该差不多啦

Ⅳ 下列更合适表示队列的链表结构() A.单向链表 B.单向循环链表 C.双向链表 D.双向循环链表

前提:队列中的结点从队尾插入，从队头删除;队列中的结点的指向是从队头指向队尾，因回为是循环链答表，则队尾结点的下一个结点是队头。 如果只设头指针，则出列容易，头指针往后移一个就行;入列则要遍历整个队列，确定队尾后再插入，所以出列是O(1)，入列是O(n) 如果只设尾指针，则入列时直接插入，出列只须后移一个结点即可找到队头结点，都是常数级的时间耗费，即都是O(1) 一般来说循环队列不用设头指针，只需一个指向尾结点的指针就行了，确定头和尾都很容易。

Ⅳ 用C语言编写队列程序

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define NULL 0
#define OK 1
#define OVERFLOW 0
#define ERROR 0
typedef int QElemType;
typedef int Status;
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear;//队头，队尾指针
};
//函数列表
void InitQueue(LinkQueue &Q)
{//初始化一个队列
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front)//生成头结点失败
exit(OVERFLOW);
Q.front->next=NULL;
}
void DestoryQueue(LinkQueue &Q)
{ //销毁队列
while(Q.front)
{
Q.rear=Q.front->next;//Q.rear指向Q.front的下一个结点
free(Q.front);//释放Q.front所指结点
Q.front=Q.rear;//Q.front指向Q.front的下一个结点
}
}
void ClearQueue(LinkQueue &Q)
{ //将队列清为空
DestoryQueue(Q);//销毁队列
InitQueue(Q);//重新构造队列
}
Status QueueEmpty(LinkQueue Q)
{ //判断队列是否为空
if(Q.front->next==NULL)
return TRUE;
else return FALSE;
}
int QueueLength(LinkQueue Q)
{ //求队列的长度
int i=0;//计数器清0
QueuePtr p=Q.front;//p指向结点
while(Q.rear!=p)//p所指向的不是尾结点
{
i++;//计数器加1
p=p->next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType &e)
{ //若队列不空，则用e返回队头元素
QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front->next;//p指向队头结点
e=p->data;//将队头元素的值赋给e
return OK;
}
void EnQueue(LinkQueue &Q,QElemType e)
{ //插入元素e为队列Q的新的队尾元素
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
//动态生成新结点
if(!p)
exit(OVERFLOW);
p->data=e;//将e的值赋给新结点
p->next=NULL;//新结点的指针为空
Q.rear->next=p;//原队尾结点的指针域为指向新结点
Q.rear=p;//尾指针指向新结点
}
Status DeQueue(LinkQueue &Q,QElemType &e)
{ //若队列不为空，删除Q的队头元素，用e返回其值
QueuePtr p;
if(Q.front==Q.rear)//队列为空
return ERROR;
p=Q.front->next;//p指向队头结点
e=p->data;//队头元素赋给e
Q.front->next=p->next;//头结点指向下一个结点
if(Q.rear==p)//如果删除的队尾结点
Q.rear=Q.front;//修改队尾指针指向头结点
free(p);
return OK;
}
void QueueTraverse(LinkQueue Q,void(*visit)(QElemType))
{ //对队头到队尾依次对队列中每个元素调用函数visit()
QueuePtr p;
p=Q.front->next;
while(p)
{
visit(p->data);//对p所指元素调用visit()
p=p->next;
}
printf("\n");
}
void print(QElemType e)
{
printf("%2d",e);
}
void main()
{
int i,k;
QElemType d;
LinkQueue q;
InitQueue(q);//构造一个空栈
for(i=1;i<=5;i++)
{
EnQueue(q,i);
}
printf("栈的元素为:");
QueueTraverse(q,print);
k=QueueEmpty(q);
printf("判断栈是否为空,k=%d(1:为空9;0:不为空)\n",k);
printf("将队头元素赋给d\n");
k=GetHead(q,d);
printf("队头元素为d=%d\n",d);
printf("删除队头元素:\n");
DeQueue(q,d);
k=GetHead(q,d);
printf("删除后新的队头元素为d=%d\n",d);
printf("此时队列的长度为%d\n",QueueLength(q));
ClearQueue(q);//清空队列
printf("清空队列后q.front=%u,q.rear=%u,q.front->next=%u\n",q.front,q.rear,q.front->next);
DestoryQueue(q);
printf("销毁队列后,q.front=%u,q.rear=%u\n",q.front,q.rear);

Ⅵ C语言的队列如何实现和表示

我能想抄到的有两种方法（假设队列元素袭都是int）
一，用链表的方法
struct A
{
int n;
struct A *a;
} *p,*head,*rear;
head=rear=NULL；/*头指针，尾指针*/
添加元素：p=(struct A*)malloc(sizeof(struct A));......给新元素赋值.....;rear->a=p;rear=p;
当然添加第一个元素的时候要给head赋值。
删除元素：p=head;head=head->a;free(p);
用的是单向链表，当然也可以用双向链表，不过删除，添加元素的过程要麻烦点。
二，利用数组，当然也可以开辟动态储存空间
int a[N]，*head,*rear; N就是个常数
head=rear=a;
添加元素：scanf("%d",rear-a==N?rear=a:++rear);
删除元素：head-a==N?head=a:head++;
当然要检查队列是否溢出，可以设变量n=0;
每次添加元素n++
每次删除元素n--
当n<0后n>N数据溢出

Ⅶ C语言 用队列求解迷宫问题

#include <stdio.h>
#define Maxsize 100
#define N 10
int M[N+2][N+2]=
{
{1,1,1,1,1,1,1,1,1,1,1,1},
{1,0,1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,1,0,1,0,1,0,0,1},
{1,0,0,0,1,1,1,0,1,1,0,1},
{1,1,0,0,0,0,0,0,1,0,0,1},
{1,0,1,1,1,1,1,1,1,0,1,1},
{1,0,0,0,0,1,1,0,1,0,0,1},
{1,1,0,1,0,0,0,0,1,0,1,1},
{1,0,0,1,1,0,1,0,0,0,0,1},
{1,0,1,1,0,0,0,1,1,1,1,1},
{1,0,0,0,0,1,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1,1,1}
};
struct path
{
int i,j,p;
}Q[Maxsize];
int front=-1;
int rear=-1;
void print(int front)
{
int k=front,i=0,j;
while(k!=0)
{
=k;
k=Q[k].p;
Q[j].p=-1;
}
printf("迷宫最快捷路径如下：\n");
k=0;
while(k<Maxsize)
{
if(Q[k].p==-1)
{
i++;
printf("{%d,%d}\t",Q[k].i,Q[k].j);
M[Q[k].i][Q[k].j]=0;
if(i%5==0)
printf("\n");
}
k++;
}
printf("\n迷宫最快捷路径如图所示：\n");
for(i=0;i<12;i++)
{
for(j=0;j<12;j++)
{
if(M[i][j]==-1)
printf("%c%c",161,245);
else if(M[i][j]==0)
printf("%c%c",161,242);
else
printf("%c%c",161,246);
}
printf("\n");
}
}

int labyrinth(int x1,int y1,int x2,int y2)
{
int i,j,find=0,di;
rear++;
Q[rear].i=x1;Q[rear].j=y1;Q[rear].p=-1;
M[1][1]=-1;
while(front<=rear&&find==0)
{
front++;
i=Q[front].i;j=Q[front].j;
if(i==x2&&j==y2)
{
find=1;
print(front);
return 1;
}
for(di=0;di<4;di++)
{
switch(di)
{
case 0:
i=Q[front].i-1;j=Q[front].j;break;
case 1:
i=Q[front].i;j=Q[front].j+1;break;
case 2:
i=Q[front].i+1;j=Q[front].j;break;
case 3:
i=Q[front].i;j=Q[front].j-1;break;
}
if(M[i][j]==0)
{
rear++;
Q[rear].i=i;Q[rear].j=j;Q[rear].p=front;
M[i][j]=-1;
}
}
}
return 0;
}
void main()
{
labyrinth(1,1,N,N);
}

在vc上运行

Ⅷ c语言 队列的操作

//定义队列结构体
typedef struct Qnode
{
int data;
struct Qnode *next;
} Queue , *QueuePtr;

typedef struct
{
QueuePtr front;
QueuePtr rear;
} linkQnode;
//创建一个队列
initQueue (linkQnode *q)
{
q -> front = q -> rear = (QueuePtr) malloc (sizeof (Queue));
if (!q -> front) exit (0);
q -> front -> next = NULL;
}
//入队列
EnterQueue (linkQnode *q , int item)
{
QueuePtr p;
p = (QueuePtr) malloc (sizeof (Queue));
if (!p) exit (0);
p -> data = item;
p -> next = NULL;
q -> rear -> next = p;
q -> rear = p;
}
//出队列
DelQueue (linkQnode *q , int *item)
{
QueuePtr p;
if (q -> front = q -> rear) return;
p = q -> front -> next;
*item = p -> data;
q -> front -> next = p -> next;
if (q -> rear == p)
q -> rear = q -> front;
free (p);
}

Ⅸ C语言 用单链表实现队列

网络答案，已验证：
#include<stdio.h>
#include<stdlib.h>
struct Node
{
int data; /*值域*/
struct Node *next; /*链接指针*/
};
struct queue
{
struct Node *front; /*队首指针*/
struct Node *rear; /*队尾指针*/
};
/*初始化链队*/
void initQueue(struct queue *hq)
{
hq->front=hq->rear=NULL; /*把队首和队尾指针置空*/
}
/*向链队中插入一个元素x*/
void inQueue(struct queue *hq, int x)
{
struct Node *newNode; /*得到一个由newNode指针所指向的新结点*/
newNode=malloc(sizeof(struct Node));
if(newNode==NULL)
{
printf("内存空间分配失败！ ");
exit(1);
}
newNode->data=x; /*把x的值赋给新结点的值域*/
newNode->next=NULL; /*把新结点的指针域置空*/
/*若链队为空，则新结点即是队首结点又是队尾结点*/
if(hq->rear==NULL)
{
hq->front=hq->rear=newNode;
}else
{
/*若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点*/
hq->rear=hq->rear->next=newNode;
}
//return;
}
/*从队列中删除一个元素*/
int delQueue(struct queue*hq)
{
struct Node*p;
int temp;
/*若链队为空则停止运行*/
if(hq->front==NULL)
{
printf("队列为空，无法删除！ ");
exit(1);
}
temp=hq->front->data;
/*暂存队首元素以便返回*/
p=hq->front;
/*暂存队首指针以便回收队尾结点*/
hq->front=p->next; /*使队首指针指向下一个结点*/
/*若删除后链队为空，则需同时使队尾指针为空*/
if(hq->front==NULL)
{
hq->rear=NULL;
}
free(p); /*回收原队首结点*/
return temp; /*返回被删除的队首元素值*/
}
/*读取队首元素*/
int peekQueue(struct queue *hq)
{ /*若链队为空则停止运行*/
if(hq->front==NULL)
{
printf("队列为空，无法删除！ ");
exit(1);
}
return hq->front->data; /*返回队首元素*/
}
/*检查链队是否为空，若为空则返回1,否则返回0*/
int emptyQueue(struct queue *hq)
{
/*判断队首或队尾任一个指针是否为空即可*/
if(hq->front==NULL)
{
return 1;
}else
{
return 0;
}
}
/*清除链队中的所有元素*/
void clearQueue(struct queue *hq)
{
struct Node *p=hq->front; /*队首指针赋给p*/
/*依次删除队列中的每一个结点，最后使队首指针为空*/
while(p!=NULL)
{
hq->front=hq->front->next;
free(p);
p=hq->front;
}
/*循环结束后队首指针已经为空*/
hq->rear=NULL; /*置队尾指针为空*/
return;
}
int main(int argc,char *argv[])
{
struct queue q;
int a[8]={3,8,5,17,9,30,15,22};
int i;
initQueue(&q);
for(i=0;i<8;i++)
{
inQueue(&q,a[i]);
}
printf("delnode is %d\n",delQueue(&q));
printf("delnode is %d\n",delQueue(&q));
inQueue(&q,68);
printf("peeknode is %d\n",peekQueue(&q));
while(!emptyQueue(&q))
{
printf("%d\n",delQueue(&q));
}
clearQueue(&q);
}

Ⅹ C语言中使用队列

如果抄你用vc，#include<deque>就好了，袭但是注意要加上using naemspace std；
我是当你用的c++的STL，STL中没有真正的队列和栈，他们都是通过对双端队列的改造得到的，所以包含的文件可能和你想的不一样。而且这些头文件都没有.h结尾！很特别
如果你不是vc，当我没说