Ⅰ 數據結構（使用c語言）隊列
對順序循環隊列，常規的設計方法是使用隊尾指針和隊頭指針，隊尾指針用於指出當前胡隊尾位置下標，隊頭指針用於指示當前隊頭位置下標。現要求：
（1）設計一個使用隊頭指針和計數器胡順序循環循環隊列抽象數據類型，其中包括：初始化，入隊列，出隊列，取隊頭元素肯判斷隊列是否非空；
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"conio.h"
#defineMAX80
typedefstruct
{
intdata[MAX];
intfront,rear;
intnum;
}SeQue;
SeQue*Init_SeQue()
{
SeQue*s;
s=newSeQue;
s->front=s->rear=MAX-1;
s->num=0;
returns;
}
intEmpty_SeQue(SeQue*s)
{
if(s->num==0)
return1;
else
return0;
}
intIn_SeQue(SeQue*s,intx)
{
if(s->num==MAX)
return0;
else
{
s->rear=(s->rear+1)%MAX;
s->data[s->rear]=x;
s->num++;
return1;
}
}
intOut_SeQue(SeQue*s,int*x)
{
if(Empty_SeQue(s))
return0;
else
{
s->front=(s->front+1)%MAX;
*x=s->data[s->front];
s->num--;
return1;
}
}
voidPrint_SeQue(SeQue*s)
{
inti,n;
i=(s->front+1)%MAX;
n=s->num;
while(n>0)
{printf("%d",s->data[i]);
i=(i+1)%MAX;
n--;
}
}
voidmain()
{
SeQue*s;
intk,flag,x;
s=Init_SeQue();
do{
printf("\");
printf("\t\t\t循環順序隊列");
printf("\t\t\t***********************");
printf("\t\t\t**1-入隊**");
printf("\t\t\t**2-出隊**");
printf("\t\t\t**3-判隊空**");
printf("\t\t\t**4-隊列顯示**");
printf("\t\t\t**0-返回**");
printf("\t\t\t***********************");
printf("\t\t\t請輸入菜單項(0-4):");
scanf("%d",&k);
switch(k)
{
case1:
printf("請輸入入隊元素:");
scanf("%d",&x);
flag=In_SeQue(s,x);
if(flag==0)
printf("隊滿不能入隊!按任意鍵返回..");
else
printf("元素已入隊!按任意鍵返回..");
getch();
system("cls");
break;
case2:
flag=Out_SeQue(s,&x);
if(flag==0)
printf("隊列空出隊失敗!按任意鍵返回..");
else
printf("隊列頭元素已出隊~!按任意鍵返回..");
getch();
system("cls");
break;
case3:
flag=Empty_SeQue(s);
if(flag==1)
printf("該隊列為空!按任意鍵返回..");
else
printf("該隊列不為空!按任意鍵返回..");
getch();
system("cls");
break;
case4:
printf("該隊列元素為:");
Print_SeQue(s);
printf("按任意鍵返回..");
getch();
system("cls");
break;
}
}while(k!=0);
}
Ⅱ 用C語言編寫隊列的各種基本操作，我不是非常明白：注釋里有些問題：請大家講講，如果可能，請詳細講講各種
ont）進行刪除操作，而在表的後端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。 在隊列這種數據結構中，最先插入在元素將是最先被刪除；反之最後插入的元素將最後被刪除，因此隊列又稱為「先進先出」（FIFO—first in first out）的線性表。 隊列空的條件：front=rear 隊列滿的條件： rear = MAXSIZE 隊列可以用數組Q[1…m]來存儲，數組的上界m即是隊列所容許的最大容量。在隊列的運算中需設兩個指針：head，隊頭指針，指向實際隊頭元素的前一個位置；tail，隊尾指針，指向實際隊尾元素所在的位置。一般情況下，兩個指針的初值設為0，這時隊列為空，沒有元素。圖1 ( a)畫出了一個由6個元素構成的隊列，數組定義Q[1…10]。Q(i) i=3,4,5,6,7,8頭指針head＝2，尾指針tail＝8。隊列中擁有的元素個數為:L=tail-head現要讓排頭的元素出隊，則需將頭指針加1。即head=head+1這時頭指針向上移動一個位置，指向Q(3)，表示Q(3)已出隊。見圖1 (b)。如果想讓一個新元素入隊，則需尾指針向上移動一個位置。即tail=tail+1這時Q(9)入隊，見圖1 (c)。當隊尾已經處理在最上面時，即tail=10，如果還要執行入隊操作，則要發生"上溢"，但實際上隊列中還有三個空位置，所以這種溢出稱為"假溢出"。 克服假溢出的方法有兩種。一種是將隊列中的所有元素均向低地址區移動，顯然這種方法是很浪費時間的；另一種方法是將數組存儲區看成是一個首尾相接的環形區域。當存放到n地址後，下一個地址就"翻轉"為1。在結構上採用這種技巧來存儲的隊列稱為循環隊列。 隊列和棧一樣只允許在斷點處插入和刪除元素。 循環隊的入隊演算法如下： 1、tail=tail+1； 2、若tail=n+1，則tail=1； 3、若head=tail尾指針與頭指針重合了，表示元素已裝滿隊列，則作上溢出錯處理； 4、否則，Q(tail)=X，結束（X為新入出元素）。 隊列和棧一樣，有著非常廣泛的應用。
具體網上查:
另外,虛機團上產品團購,超級便宜
Ⅲ 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>
#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語言，數據結構寫個隊列的程序
首先要明白隊列是 先進先出 InQueue(Q,'H'); InQueue(Q,'R'); InQueue(Q,y); //現在隊列內容從前到後依次是HRC OutQueue(Q,x);InQueue(Q,x); //,H 出隊列,並且把H賦於x,然後x='H' 入隊列,現在隊列內容從前到後依次是RCH ...
Ⅵ C語言寫 棧隊列(先進先出的)
#include<stdio.h>
#include<malloc.h>typedef
struct
node
/*定義新類型結構體結點*/
{
int
data;/*數據成員可以是多個不同類型的數據*/
struct
node
*next;/*指針變數成員只能是一個*/
}NODE;/*節點結束*/typedef
struct
qnode
/*定義結點類型的變數名*/
{
NODE
*front;/*設定結點頭指針變數*/
NODE
*rear;/*
設定結點尾指針變數*/
}QNODE;
/*
鏈隊列的結點定義
*/
void
InitQueue(QNODE
*Q)/*定義指針Q*/
{
NODE
*p;/*定義指針p*/
p=(NODE
*)malloc(sizeof(NODE));/*分配結點位元組的容量*/
Q->front=p;
/*指定頭指針p*/
Q->front->next=NULL;/*建立空隊列*/
Q->rear=Q->front;/*改變Q的值*/
printf("The
init
is
complete!");}
void
*QueuePush(QNODE
*Q)
{
NODE
*p;
p=(NODE
*)malloc(sizeof(NODE));/*分配結點位元組的容量*/
printf("Please
input
a
number
:");/*請輸入一個數*/
scanf("%d",&p->data);/*給第一個結點賦值*/
p->next=NULL;/*指定尾結點*/
Q->rear->next=p;/*指定尾新結點p的地址*/
Q->rear=p;/*指定隊尾結束*/
printf("The
%d
has
been
pushed
into
the
Queue!",p->data);/*顯示數據成員*/
return
0;/*程序結束*/
}
void
*QueuePop(QNODE
*Q)
{
NODE
*p;/*定義結點指針*/
if(Q->front->next==NULL)
return
0;/*判斷對前是否為空，如果是就結束*/
p=Q->front->next;/*指向下以個成員*/
Q->front->next=p->next;/*依次向下循環*/
if(Q->rear==p)
Q->rear=Q->front;/*隊尾與對頭相同*/
printf("The
%d
has
been
pop
from
the
queue!
\n",p->data);/*顯示隊列成員*/
free(p);
return
0;
}
void
*PrintQueue(QNODE
*Q)
{
NODE
*p;/*定義鏈結點*/
p=Q->front->next;/*指定對頭*/
while(p!=NULL)/*如不為空*/
{
printf("%5d",p->data);/*顯示數據成員*/
p=p->next;/*指定第二個成員*/
}
return
0;
}
void
main()
{
QNODE
*T;
int
i=0;/*取值*/
printf("1.InitQueue
2.QueuePush
3.QueuePop
4.PrintQueue
5.Quit
\n");
while(i!=5)
{
printf("Please
choose
the
gongneng:");
scanf("%d",&i);
printf("\n");
switch(i)
{
case
1:
InitQueue(T);
printf("\n");
break;
case
2:
QueuePush(T);
printf("\n");
break;
case
3:
QueuePop(T);
printf("\n");
break;
case
4:
printf("The
queue's
numbers
are:");
PrintQueue(T);
printf("\n");
break;
case
5:
printf("\n");
break;}
}
}
Ⅶ C語言中隊列怎樣創建
隊列是一種特殊的鏈表,在你寫GET和PUT方法時只需要返回鏈表的第一個值,把你要輸的值放鏈表的最後就是隊列了!!!
Ⅷ c語言隊列操作
pq->rear->next
=
pnew這個代碼從隊列的尾部增加新節點，
然後pq->rear
=
pnew更新隊列尾部指針。隊列的數據結構形式就是由一個頭front指針，一個尾rear指針來表徵，items的設計是用空間換時間，涉及隊列大小的操作會非常方便。
隊列的特徵是先進先出，你給出的鏈式實現，其實就跟一個鏈表一樣，鏈表的添加刪除如果能理解了，隊列只是鏈表的元素增加/刪除
按先進先出特點的一種實現。
但對於隊列來說，實現方式不是重點，先進先出的性質才是重點，這在實際應用中很多，比如排隊叫號。
Ⅸ C語言中使用隊列
如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是當你用的c++的STL，STL中沒有真正的隊列和棧，他們都是通過對雙端隊列的改造得到的，所以包含的文件可能和你想的不一樣。而且這些頭文件都沒有.h結尾！很特別
如果你不是vc，當我沒說