① c語言實現隊列的基本操作
structpQueue
{
ElemType*head;//指向開辟的空間的首地址
Elemtype*tail;
intlength;//(總容量)
intL_now;//(當前容量)
};
if(pQueue.L_now==pQueue.length)
{
每次申請空間都是+N
}
pQueue->tail=p;
② 用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語言實現隊列和棧的方法
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define N 20
typedef char SElemType;
typedef int Status;typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;#include<stdio.h>
#include<stdlib.h>Status CreatStack(SqStack &S){
//創建棧
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//CreatStackStatus Push(SqStack &S,SElemType e){
//插入e為新的棧頂元素
if(S.top-S.base>=S.stacksize){//棧滿，追加存儲空間
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit (OVERFLOW);//存儲空間分配失敗
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//PushStatus Pop(SqStack &S ,SElemType &e){
//若棧不空，刪除棧頂元素，並用e返回其值
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}//Pop typedef char QElemType;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QNodePtr;typedef struct{
QNodePtr front;
QNodePtr rear;
}LinkQueue;Status CreatQueue(LinkQueue &Q){
//建立一個空的鏈式棧
Q.front=Q.rear=(QNodePtr)malloc(sizeof(QNode));
if(!Q.front)exit(OVERFLOW);
Q.front->next=NULL;
return OK;
}Status EnQueue(LinkQueue &Q,QElemType e){ QNodePtr p;
p=(QNodePtr)malloc(sizeof(QNode));
if(!p)exit(OVERFLOW);
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}Status DeQueue(LinkQueue &Q,QElemType &e){QNodePtr p;<br>if(Q.front==Q.rear) return ERROR;<br>p=Q.front->next; e=p->data;<br>Q.front->next=p->next;<br>if(Q.rear==p) Q.rear=Q.front;<br>free(p);<br>return OK;<br>}int stackPalindrom_Test()//判別輸入的字元串是否迴文序列,是則返回1,否則返回0
{
printf("棧練習，請輸入要判斷的字元串以#作為結束符，不要超過二十個字元\n");
SqStack S;
CreatStack(S);
char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
Push(S,b[count]); //進棧
count++;
}
int i = 0;
while(i < count)
{
Pop(S,a);
if(a!=b[i])
return ERROR;
i++;
}
return OK;}//stackPalindrom_Test int queuePalindrom_Test()//判別輸入的字元串是否迴文序列,是則返回1,否則返回0
{
printf("隊列練習，請輸入要判斷的字元串以#作為結束符，不要超過二十個字元\n");
LinkQueue Q;
CreatQueue(Q); char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
EnQueue(Q,b[count]);; //入列
count++;
} while(count-- > 0)
{
DeQueue(Q,a);
if(a!=b[count])
return ERROR;
}
return OK;
}//queuePalindrom_Test Status main(){ if(stackPalindrom_Test()==1)
printf("是迴文\n");
else printf("不是迴文\n"); if(queuePalindrom_Test()==1)
printf("是迴文\n");
else printf("不是迴文\n");
return OK;
}
④ 數據結構（使用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語言編寫隊列程序
#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語言 求隊列的簡單例子
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream.h>
#define TURE 1
#define FALSE 0
#define OVERFLOW 0
#define OK 1
#define ERROR 0
#define MAXQSIZE 100
typedef int qelemtype;
typedef int status;
typedef struct{
qelemtype *base;
int front;
int rear;
}sqqueue;
status initqueue(sqqueue &q){
q.base=(qelemtype*)malloc(MAXQSIZE*sizeof(qelemtype));
if(!q.base)exit(OVERFLOW);
q.front=q.rear=0;
return OK;
}//構造一個空隊列
void visit(int &y){
y=2*y;
cout<<y<<" ";
}
status destroyqueue(sqqueue &q){
while(q.front){
q.rear=q.front;
free(q.base);
q.front=q.rear;
}
return OK;
}//銷毀隊列
status clearqueue(sqqueue &q){
q.front=q.rear=0;
return OK;
}//清空隊列
status queueempty(sqqueue q){
if(q.front==q.rear)
return TURE;
return FALSE;
}//若隊列為空,返回TURE,否則返回FALSE.
status queuelength(sqqueue q){
return(q.rear-q.front+MAXQSIZE)%MAXQSIZE;
}//返回隊列元素個數,即為隊列長度
status gethead(sqqueue q,qelemtype &e){
if(q.front==q.rear)return ERROR;
e=q.base[q.front];
cout<<e<<endl;
return OK;
}//若隊列不空,則用e返回隊列的頭元素,並返回OK
status enqueue(sqqueue &q,qelemtype e){
if((q.rear+1)%MAXQSIZE==q.front)return ERROR;
q.base[q.rear]=e;
q.rear=(q.rear+1)%MAXQSIZE;
return OK;
}//插入元素e為q的新的隊尾元素
status dequeue(sqqueue &q,qelemtype &e){
if(q.front==q.rear)return ERROR;
e=q.base[q.front];
q.front=(q.front+1)%MAXQSIZE;
return OK;
}//若隊列不空,則刪除q的隊頭元素,用e返回其值,並返回OK.
status queuetraverse(sqqueue q,void(*visit)(int &p)){
int i=1,p,a;
a=q.front;
p=q.base[a];
while(i<=(q.rear-q.front+MAXQSIZE)%MAXQSIZE)
{
visit(p);
a++;
i++;
};
return OK;}
//從隊頭到隊尾依次對隊列調用函數visit().
void main(){
sqqueue q;
int a,b,e,i,j,k;
initqueue(q);
cout<<"初始化後隊頭地址:"<<q.base<<endl;
cout<<"新建隊列!"<<endl;
cout<<"當前隊列是否為空:"<<queueempty(q)<<endl;
cout<<"定義隊列長度:"<<endl;
cin>>a;
cout<<"分別輸入隊列的各個元素,按ENTER"<<endl;
for(k=1;k<=a;k++){
cin>>j;
i=enqueue(q,j);}
cout<<"現隊列元素:"<<endl;
for(b=1;b<=a;b++)
cout<<q.base[b-1]<<endl;
cout<<"當前隊列長度:"<<queuelength(q)<<endl;
cout<<"當前隊頭元素:"<<endl;
gethead(q,e);
cout<<"刪除當前頭元素!返回其值"<<endl;
dequeue(q,i);
cout<<i<<endl;
cout<<"調用函數後隊列變為:";
queuetraverse(q,visit);
cout<<endl;
cout<<"清空隊列!"<<clearqueue(q)<<endl;
cout<<"銷毀隊列!"<<destroyqueue(q)<<endl;
}
⑦ 請大家幫忙用c語言編個隊列的源程序
#include <stdio.h>
#include <stdlib.h>
typedef struct QNode{
int data;
struct QNode *next;
} LinkNode;//每個結點的定義
typedef struct{
LinkNode *front, *rear;
}LinkQuene;//採用鏈表結構的隊列
void InitQuene(LinkQuene &Q)//帶有頭結點的隊列
{
Q.front=(LinkNode *)malloc(sizeof(QNode));
Q.rear=Q.front;
}
bool EmptyQuene(LinkQuene Q)
{
if(Q.front==Q.rear)
return true;
else
return false;
}
void QueneTraverse(LinkQuene Q)
{
if(EmptyQuene(Q)==false)
{
LinkNode *p=Q.front->next;
printf("\n當前隊列的遍歷序列為：");
while(p!=Q.rear)
{
printf("%d->",p->data);
p=p->next;
}
printf("%d\n",p->data);
}
}
void EnQuene(LinkQuene &Q, int e)
{
LinkNode *p=(LinkNode *)malloc(sizeof(QNode));
if(!p)
exit(0);
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
}
void DeQuene(LinkQuene &Q, int &e)
{
LinkNode *p;
if(EmptyQuene(Q))
{ printf("隊列為空！\n");
exit(0);
}
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
}
void menu()
{
printf("\n***************************\n");
printf("**[1]新建隊列 **\n");
printf("**[2]入隊列 **\n");
printf("**[3]出隊列 **\n");
printf("**[4]遍歷整個隊列 **\n");
printf("**[0]退出 **\n");
printf("***************************\n");
printf("請輸入命令：\n");
}
void main()
{
LinkQuene Q;
InitQuene(Q);
int a,order;
char ans,temp;
while(1)
{
menu();
ans='n';
scanf("%d",&order);
switch(order)
{
case 1:
do{
printf("請輸入隊列的元素：\n");
scanf("%d",&a);
fflush(stdin); //清空鍵盤緩沖區（過濾回車）
EnQuene(Q,a);
printf("是否繼續添加元素？(Y/N)");
scanf("%c",&ans);
fflush(stdin);
}while(ans=='y' || ans =='Y');
QueneTraverse(Q);
break;
case 2:
if( EmptyQuene(Q))
{
printf("隊列為空!\n");
break;
}
do{
printf("請輸入添加到隊列的元素：\n");
scanf("%d",&a);
fflush(stdin);
EnQuene(Q,a);
printf("是否繼續添加元素?(Y/N)");
scanf("%c",&ans);
fflush(stdin);
}while(ans=='y' || ans =='y');
QueneTraverse(Q);
break;
case 3:
if(EmptyQuene(Q))
{
printf("隊列為空!\n");
break;
}
else{
do{
DeQuene(Q,a);
fflush(stdin);
printf("元素%d已經出隊列\n",a);
if(EmptyQuene(Q)==false)
{
printf("是否繼續出隊列?(Y/N)");
scanf("%c",&ans);
}
else
{
printf("隊列已空!\n");
break;
}
}while(ans=='y' || ans =='y');
QueneTraverse(Q);
break;
}
case 4:
if(EmptyQuene(Q))
{
printf("隊列為空!\n");
break;
}
QueneTraverse(Q);break;
case 0:
exit(0);
default:
printf("您輸入的命令有誤!\n");
}
}
}
⑧ 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 <stdlib.h>
struct node
{
int data;
struct node *next;
};
typedef struct node Node;
int ifnull(Node *tail)
{
if(tail->next==NULL)
return 0;
return 1;
}
Node *qinit(Node *tail)
{
tail=(Node *)malloc(sizeof(Node));
tail->data=0;
tail->next=NULL;
return tail;
}
void push(Node *tail,int data)
{
if(tail==NULL)
{
perror("error!");
return;
}
Node *tmp=NULL;
if(ifnull(tail)==0)
tmp=tail;
else
tmp=(Node *)malloc(sizeof(Node));
tmp->data=data;
tmp->next=tail->next;
tail->next=tmp;
tail=tmp;
}
void pop(Node *tail)
{
if(tail==NULL)
{
perror("error!");
return;
}
if(ifnull(tail)==0)
printf("queue is empty!");
if(tail->next==tail)
{
free(tail);
tail=NULL;
return;
}
Node *tmp=tail->next;
while(1)
{
if(tmp->next==tail)
{
Node *n=tail;
tail=tmp;
tail->next=n->next;
free(n);
break;
}
tmp=tmp->next;
}
}
Node *getdata(Node *tail,int *data)
{
if(tail==NULL)
{
perror("error!");
return;
}
if(ifnull(tail)==0)
{
printf("queue is empty!");
return;
}
if(tail->next==tail)
{
*data=tail->data;
tail->data=0;
tail->next=NULL;
return tail;
}
Node *tmp=tail->next;
while(1)
{
if(tmp->next==tail)
{
Node *n=tail->next;
*data=tail->data;
free(tail);
tail=tmp;
tail->next=n;
break;
}
tmp=tmp->next;
}
return tail;
}
int main()
{
Node *tail=NULL;
tail=qinit(tail);
if(ifnull(tail))
printf("not null\n");
else
printf("is null\n");
int a[10]={0};
int i=1;
for(i=1;i<=10;i++)
push(tail,i);
for(i=0;i<10;i++)
{
tail=getdata(tail,&a[i]);
printf("%d,",a[i]);
}
printf("\n");
free(tail);
return 0;
}
⑩ 隊列 c語言程序編程
SeqCQueue queue;
初始化
void init(void)
{
for(int i=0 ; i<=MaxSize ; i++)
queue.data[i] = 0;
queue.front = 0;
queue.rear = -1;
}
插入
void insert(int x)
{
queue.rear ++;
queue.data[queue.rear] = x;
}
void delete(void)
{
queue.data[queue.front] = 0;
queue.front ++;
}
自己直接寫的。
main和其他的，自己搞定吧。