栈是先进后出，队列则是先进先出.下面贴一下队列的基本操作.
### 1.队列的顺序表示.
#### 1.1队列的结构体定义
~~~
#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
#define MAXNUM 20 /*队列中元素的最大个数*/
struct Seqqueue /*顺序队列类型定义*/
{
int f,r;
DataType q[MAXNUM];
};
typedef struct Seqqueue Seqqueue,*PSeqqueue;
/*创建一个空队列*/
PSeqqueue createEmptyqueue(void);
/*判断队列是否为空*/
int isEmptyqueue_seq(PSeqqueue paqu);
/*在队列中插入一个元素*/
void enqueue_seq(PSeqqueue paqu,DataType x);
/*删除队头元素*/
void dequeue_seq(PSeqqueue paqu);
/*对非空队列求队头元素*/
DataType frontqueue_seq(PSeqqueue paqu);
~~~
#### 1.2创建队列
~~~
PSeqqueue createEmptyqueue(){
PSeqqueue paqu=(PSeqqueue)malloc(sizeof(struct Seqqueue));
if (paqu==NULL)
{
printf("Out of space.\n");
}else{
paqu->r=paqu->f=0;
}
return paqu;
}
~~~
#### 1.3队列中插入元素
~~~
void enqueue_seq(PSeqqueue paqu,DataType x){
if ((paqu->r+1)%MAXNUM==paqu->f)
{
printf("Full queue.\n");
}else{
paqu->q[paqu->r]=x;
paqu->r=(paqu->r+1)%MAXNUM;
}
}
~~~
#### 1.4删除对头元素
~~~
void dequeue_seq(PSeqqueue paqu){
if (isEmptyqueue_seq(paqu))
{
printf("Empty queue\n");
}else{
paqu->f=(paqu->f+1)%MAXNUM;
}
}
~~~
#### 1.5返回对头元素
~~~
DataType frontqueue_seq(PSeqqueue paqu){
return paqu->q[paqu->f];
}
~~~
#### 1.6判断队列是否为空.
~~~
int isEmptyqueue_seq(PSeqqueue paqu){
return paqu->f=paqu->r;
}
~~~
#### 1.7测试
~~~
int main(){
PSeqqueue queue=createEmptyqueue();
enqueue_seq(queue,2);
enqueue_seq(queue,3);
enqueue_seq(queue,4);
printf("%d\n",frontqueue_seq(queue));
return 0;
}
~~~
###2.队列的链式表示
#### 2.1结构体定义和函数声明
~~~
#include <stdio.h>
#include <stdlib.h>
typedef int Datatype;
struct Node;
typedef struct Node *PNode;
struct Node
{
Datatype info;
PNode link;
};
struct LinkQueue
{
PNode f;
PNode r;
};
typedef struct LinkQueue *PLinkQueue;
//创建一个空队列
PLinkQueue createEmptyQueue_link();
//判断队列是否为空
int isEmptyQueue_link(PLinkQueue plqu);
//进队列
void enQueue_link(PLinkQueue plqu,Datatype x);
//出对列
void deQueue_link(PLinkQueue plqu);
//在非空队列中求对头元素
Datatype frontqueue_link(PLinkQueue plqu);
~~~
#### 2.2创建队列
~~~
PLinkQueue createEmptyQueue_link(){
PLinkQueue plqu=(PLinkQueue)malloc(sizeof(struct LinkQueue));
if (plqu==NULL)
{
printf("Out of space.\n");
}else{
// PNode pnode=(PNode)malloc(sizeof(struct Node));
plqu->f=plqu->r=NULL;
}
return plqu;
}
~~~
#### 2.3入队列
~~~
void enQueue_link(PLinkQueue plqu,Datatype x){
PNode pnode=(PNode)malloc(sizeof(struct Node));
if(pnode==NULL){
printf("Out of space.\n");
}else{
pnode->info=x;
pnode->link=NULL;
if (plqu->f==NULL)
{
plqu->f=pnode;
}else{
plqu->r->link=pnode;
}
plqu->r=pnode;
}
}
~~~
#### 2.4删除队尾元素
~~~
void deQueue_link(PLinkQueue plqu){
PNode pnode;
if (plqu->f==NULL)
{
printf("Empty Queue\n");
}else{
pnode=plqu->f;
plqu->f=plqu->f->link;
free(pnode);
}
}
~~~
#### 2.5返回对头元素
~~~
Datatype frontqueue_link(PLinkQueue plqu){
printf("%d\n",plqu->f->info);
return(plqu->f->info);
}
~~~
#### 2.6队列是否为空
~~~
int isEmptyQueue_link(PLinkQueue plqu){
return (plqu->f==NULL);
}
~~~
#### 2.7测试
~~~
int main(){
PLinkQueue p=createEmptyQueue_link();
enQueue_link(p,5);
enQueue_link(p,15);
enQueue_link(p,35);
frontqueue_link(p);
deQueue_link(p);
frontqueue_link(p);
return 0;
}
~~~
