c語言隊列操作

Ⅰ c語言實現隊列的基本操作

structpQueue
{
	ElemType*head;//指向開辟的空間的首地址
Elemtype*tail;
	intlength;//(總容量)
	intL_now;//(當前容量)
};
if(pQueue.L_now==pQueue.length)
{
每次申請空間都是+N
}
pQueue->tail=p;

Ⅱ 用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語言中使用隊列

如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是當你用的c++的STL，STL中沒有真正的隊列和棧，他們都是通過對雙端隊列的改造得到的，所以包含的文件可能和你想的不一樣。而且這些頭文件都沒有.h結尾！很特別
如果你不是vc，當我沒說

Ⅳ 二級c語言，隊列、循環隊列是什麼

隊列是一種特殊的線性表，循環隊列是將向量空間想像為一個首尾相接的圓環。

1、隊列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。

2、循環隊列是將向量空間想像為一個首尾相接的圓環，並稱這種向量為循環向量。存儲在其中的隊列稱為循環隊列。在順序隊列中，當隊尾指針已經到數組的上界，不能再有入隊操作，但其實數組中還有空位置，這就叫做「假溢出」，解決假溢出的途徑----採用循環隊列。

(4)c語言隊列操作擴展閱讀

判斷隊列滿的情況：

1、count來計數；通常使用count

Count等於隊列的MAXSIZE

2、Flag標志 int

入隊列 flag=1 出隊列flag=0

Front=rear&&flag==0

3、把一個存儲單元空出來，不存放數據

Rear+1==front

注意事項：（不要） 順序結構，SeqQueue myQueue；

Ⅳ c語言隊列操作

pq->rear->next
=
pnew這個代碼從隊列的尾部增加新節點，
然後pq->rear
=
pnew更新隊列尾部指針。隊列的數據結構形式就是由一個頭front指針，一個尾rear指針來表徵，items的設計是用空間換時間，涉及隊列大小的操作會非常方便。
隊列的特徵是先進先出，你給出的鏈式實現，其實就跟一個鏈表一樣，鏈表的添加刪除如果能理解了，隊列只是鏈表的元素增加/刪除
按先進先出特點的一種實現。
但對於隊列來說，實現方式不是重點，先進先出的性質才是重點，這在實際應用中很多，比如排隊叫號。

Ⅵ 關於C語言的隊列

可以使用c++中的容器如queue,頭文件在#include <queue>

Ⅶ 數據結構c語言版，出隊入隊及依次輸出一個隊列的操作。

#include<stdio.h>
#include<stdlib.h>

#defineElemTypeint
#defineStatusint
#defineOK1
#defineERROR0

typedefstructQNode{
ElemTypedata;
structQNode*next;
}QNode;

typedefstructLinkQueue{
QNode*front;
QNode*rear;
}LinkQueue;

StatusInitQueue(LinkQueue*q){//建立隊列
q->front=q->rear=(QNode*)malloc(sizeof(QNode));
if(!q->front)
returnERROR;
q->front->next=NULL;
returnOK;
}

StatusEnQueue(LinkQueue*q,ElemTypee){//入隊
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p->data=e;
p->next=NULL;
q->rear->next=p;//入隊操作，從隊尾(rear)進入
q->rear=p;
returnOK;
}

StatusDeQueue(LinkQueue*q,ElemType*e){//出隊
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;

p=q->front->next;//q指向的是front指針的下一個位置，亦即隊首元素
*e=p->data;
q->front->next=p->next;//出隊操作後，front++
if(q->rear==p)//判斷是否全部出隊
q->rear=q->front;//如果全部出隊，則將隊列置為空
returnOK;
}

StatusPrintfQueue(LinkQueue*Q){
QNode*p;

for(p=Q->front->next;p!=NULL;p=p->next)
printf("%d	",p->data);
}

intmain(void)
{
inti,n;
ElemTypee,de;
LinkQueue*q=(LinkQueue*)malloc(sizeof(QNode));
if(!q)
returnERROR;
InitQueue(q);

printf("以下開始構造初始隊列:

");

printf("請輸入元素個數：");
scanf("%d",&n);
printf("
");

for(i=0;i<n;++i){
	printf("請輸入第%d個元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf("
");
printf("初始隊列構造完畢！

");

printf("初始隊列：
");
PrintfQueue(q);
printf("

");
printf("======================================================

");

printf("以下開始執行入隊操作:

");

printf("請輸入需入隊的元素個數：");
scanf("%d",&n);
printf("
");

for(i=0;i<n;++i){
	printf("請輸入第%d個元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf("
");
printf("入隊%d個元素操作完畢！

",n);

printf("此時隊列:
");
	PrintfQueue(q);
	printf("

");
printf("======================================================

");

printf("以下開始執行出隊操作:

");

printf("請輸入需出隊的元素個數：");
scanf("%d",&n);
printf("
");

for(i=0;i<n;++i)
DeQueue(q,&de);
printf("
");
printf("出隊%d個元素操作完畢！

",n);

printf("此時隊列:
");
	PrintfQueue(q);
	printf("

");
printf("======================================================

");
	
free(q);
return0;
}

執行結果

Ⅷ c語言循環隊列

隊列是一種特殊的線性表，循環隊列是將向量空間想像為一個首尾相接的圓環。

隊列是一個特殊的線性表，它的特殊之處在於它只允許表的前面的操作刪除，而在表的後面的操作插入，就像堆棧一樣，隊列100是一個線性表，具有有限的操作。

循環隊列就是把向量空間想像成一個首尾相連的環，把這樣的向量稱為循環向量。存儲學位的隊列稱為循環隊列。

在順序隊列中，當指向隊列末端的指針到達數組的上界時，不能有更多的隊列條目，但數組中仍然有一個空位置。這稱為「假溢出」。

(8)c語言隊列操作擴展閱讀：

判斷滿隊列狀態：

1．計數；你通常使用count

Count等於隊列的MAXSIZE

2．國旗int

Queueinflag＝1Queueoutflag＝0

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

3．放一個存儲應答單元為空，不存儲數據

後面＋1＝前面

註：（不）順序結構，SeqQueuemyQueue；

Ⅸ C語言隊列，鏈表分別怎麼用

隊列
#include <stdio.h>
#include <stdlib.h>

#define N 11
typedef int data_t;
typedef struct sequeue {
data_t data[N];
int front, rear;
}sequeue_t;

//創建隊列
sequeue_t *create_sequeue()
{
sequeue_t *sq = malloc(sizeof(sequeue_t));
sq->front = sq->rear = 0;
return sq;
}
//判斷空
int empty_sequeue(sequeue_t *sq)
{
return sq->front == sq->rear;
}
//判斷滿(sq->rear + 1) % N == sq->front
int full_sequeue(sequeue_t *sq)
{
return (sq->rear + 1)%N == sq->front ;
}

int push_sequeue(sequeue_t *sq, data_t *data)
{
if(full_sequeue(sq))
return -1;
sq->rear = (sq->rear + 1)%N ;
sq->data[sq->rear] = *data;
return 0 ;
}
int pop_sequeue(sequeue_t *sq, data_t *data)
{
if(empty_sequeue(sq))
return -1;
sq->front = (sq->front + 1)%N ;
*data = sq->data[sq->front] ;
return 0;
}

//清空sq->front = sq->rear;
int clear_sequeue(sequeue_t *sq)
{
sq->front = sq->rear;
return 0;
}

//銷毀
int detory_sequeue(sequeue_t *sq)
{
free(sq);
return 0;
}

int main(int argc, const char *argv[])
{
data_t data;
int i;
sequeue_t *sq = create_sequeue();
for(i = 0; i < 10; i++)
{
push_sequeue(sq, &i);
}
for(i = 0; i < 10; i++)
{
pop_sequeue(sq, &data);
printf("%d ", data);
}
putchar(10);
detory_sequeue(sq);
return 0;
}

鏈表
#include <stdio.h>
#include <stdlib.h>

typedef int data_t;
typedef struct linknode {
data_t data;
struct linknode *next;
}linknode_t, linklist_t;

//創建一個鏈表
//1. 在內存總開辟頭結點的空間malloc
//2. 將頭結點的next域置空NULL
//3. 返回創建並設置好的鏈表的首地址
linklist_t *create_linklist()
{
linklist_t *node;
node=(linklist_t *)malloc(sizeof(linklist_t));
node->next=NULL;
return node;
}

//判斷當前鏈表是否為空
int empty_linklist(linklist_t *ll)
{
return ll->next == NULL;
}
//求鏈表中當前有效元素的個數
int length_linklist(linklist_t *ll)
{
int i;
for(i=0;ll->next != NULL;i++)
ll=ll->next;
return i;
}
//獲得下標為index位置的元素，成功返回0，失敗返回-1
//1. 判斷index是否合法(部分判斷)
//2. 在保證ll->next 不為空的清空下，將ll的首地址向後移動index次
//3. 判斷ll->next 是否等於空，如果等於空，則返回-1，如果不為空，執行4.
//4. 當移動了index次之後，當前ll->next 的位置的節點就保存了我要獲得的
//數據
//5. *data = ll->next->data;
//6. 返回0
int get_linklist(linklist_t *ll, int index, data_t *data)
{
int i;
if(index < 0)
return -1;
while( ll->next != NULL && index > 0)
{
ll=ll->next;
index--;
}
if( ll->next == NULL)
return -1;

*data = ll->next->data;
return 0;
}
//使用頭插法插入一個元素
//1. 創建一個節點node
//2. 將要插入的數據保存到node
//3. 執行插入操作
//4. 返回0
int insert_linklist(linklist_t *ll, data_t *data)
{
linklist_t *node;
node=(linklist_t *)malloc(sizeof(linklist_t));
node->data=*data;
node->next=ll->next;
ll->next=node;
return 0;
}
//刪除鏈表中的一個節點:刪除頭結點的後一個位置(頭刪法)
//首先可以判斷當前鏈表是否為空，如果為空返回-1
//如果不為空則刪除頭結點的下一個位置的節點
//最後返回0
int delete_linklist(linklist_t *ll)
{
linklist_t *node;
if(ll->next == 0)
return -1;
node= ll->next;
ll->next =node->next;
free(node);
return 0;
}
//清空鏈表
//循環刪除鏈表的一個節點，然後判斷刪除函數的返回值是否為0
//如果為0，繼續刪除，如果為-1則停止循環
int clear_linklist(linklist_t *ll)
{
while(delete_linklist(ll) == 0);
return 0;
}
//銷毀鏈表
//1. 調用清空操作清空鏈表
//2. 刪除頭結點
//3. 返回0
int detory_linklist(linklist_t *ll)
{
free(ll);
return 0;
}

int main(void)
{
data_t data;
int i, length;
linklist_t *ll;
ll = create_linklist(); //創建一個鏈表
for(i = 0; i < 10; i++)
{
// i=i+65;
insert_linklist(ll, &i); //賦值 4 3 2 1 0
// i=i-65;
}

length = length_linklist(ll); //長度 輸出
printf("鏈表有 %d 個數 \n",length);

for(i = 0; i < length; i++) //輸出 鏈表內容
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
putchar(10);

delete_linklist(ll); //刪除頭結點的後一個位置
length = length_linklist(ll); //長度 輸出
printf("刪除頭結點的後一個位置的鏈表\n");
for(i = 0; i < length; i++) //輸出 鏈表內容
{
get_linklist(ll, i, &data);
printf("%d ", data);
}

data = 692857680;
insert_linklist(ll, &data); //在頭節點後添加 1 個數
length = length_linklist(ll);
printf("\n在頭結點的後一個位置的添加我的QQ\n");
for(i = 0; i < length; i++)
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
putchar(10);

clear_linklist(ll); //清空鏈表
length = length_linklist(ll);
printf("清空鏈表輸出\n");
for(i = 0; i < length; i++)
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
detory_linklist(ll);
return 0;
}

Ⅹ 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數據溢出