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，當我沒說