队列的创建以及基本操作

队列(FIFO)是只允许在一段插入，另一端删除的线性表，遵循先进先出原则，队头删除，队尾插入。

顺序队列

使用用数组存储 
初始条件 front =rear=0
满队列：rear=m    容量m

空队列:   front=rear 

结构：

typedef struct
{
	int data[MAX];
	int front,rear;
}Queue;

操作：

/初始化队列
Queue InitQueue()
{
	Queue p;
	p.front=p.rear=0;
	return p;	
}

//插入
int InQueue(Queue *p,int e)
{
	p->data[++p->rear]=e;
	if(p->rear>MAX)
		return 0;
	else
	{
		printf("插入成功\n");
		return 1;	
	}			
} 

//删除
int DeQueue(Queue *p,int *e)
{
	if(p->front==p->rear)
		return 0;
	else
	{
		p->front++;                 //将队头指针后移即可删除 
		printf("删除成功\n");	
		return 0;
	}	
} 

测试：

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

#define MAX 10
//顺序队列,用数组存储 
//初始条件 front =rear=0
//满：rear=m  容量m
//空  front=rear 
typedef struct
{
	int data[MAX];
	int front,rear;
}Queue;

//初始化队列
Queue InitQueue()
{
	Queue p;
	p.front=p.rear=0;
	return p;	
}

//插入
int InQueue(Queue *p,int e)
{
	p->data[++p->rear]=e;
	if(p->rear>MAX)
		return 0;
	else
	{
		printf("插入成功\n");
		return 1;	
	}			
} 

//删除
int DeQueue(Queue *p,int *e)
{
	if(p->front==p->rear)
		return 0;
	else
	{
		p->front++;                 //将队头指针后移即可删除 
		printf("删除成功\n");	
		return 0;
	}	
} 

//打印
void print(Queue *p)
{
	while(p->front<(p->rear+1))
	{
		printf("%d",p->data[p->front]);
		p->front++;
	}
} 

int main()
{
	int a;
	Queue p;
	InitQueue();
	InQueue(&p,1);
	InQueue(&p,2);
	InQueue(&p,3);
	InQueue(&p,4);
	DeQueue(&p,&a);
	print(&p);
	return 0;
}

循环队列

front指向队头元素，rear指向队尾元素的下一个位置(防止队头队尾重合)，

当front=rear时是空队列

以下有几个公式需记：

1.设队列的最大尺寸MAX，队列满的条件是;

(rear+1)%MAX==front

2.通用的计算队列长度公式:

(rear-front+MAX)%MAX

循环队列的顺序存储结构;

typedef  struct
{
	int data[MAX];
	int front,rear;	
}SQueue;

基本操作：

//初始化   注意  
int InitQueue(SQueue *q)
{
	q->front=0;
	q->rear=0;
	return 1;
} 

//循环队列求长度
int QueueLength(SQueue *q)
{
	return (q->rear-q->front+MAX)%MAX;
}

//入队
int EnQueue(SQueue *q,int e)
{
	if((q->rear+1)%MAX==q->front)   //循环队列已满 
		return 0;
	q->data[q->rear]=e;
	q->rear=(q->rear+1)%MAX;		//将rear指针后移一位 
	return 1;		
}

//出队
int DeQueue(SQueue *q,int *e)
{
	if(q->front==q->rear)       //队列为空 
		return 0;
	*e=q->data[q->front];
	q->front=(q->front+1)%MAX;	   //front指针后移一位 
	return 1;
}

测试代码：

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

#define MAX 10

//循环链表的顺序存储
 
typedef  struct
{
	int data[MAX];
	int front,rear;	
}SQueue;

//初始化   注意  
int InitQueue(SQueue *q)
{
	q->front=0;
	q->rear=0;
	return 1;
} 

//循环队列求长度
int QueueLength(SQueue *q)
{
	return (q->rear-q->front+MAX)%MAX;
}

//入队
int EnQueue(SQueue *q,int e)
{
	if((q->rear+1)%MAX==q->front)   //循环队列已满 
		return 0;
	q->data[q->rear]=e;
	q->rear=(q->rear+1)%MAX;		//将rear指针后移一位 
	return 1;		
}

//出队
int DeQueue(SQueue *q,int *e)
{
	if(q->front==q->rear)       //队列为空 
		return 0;
	*e=q->data[q->front];
	q->front=(q->front+1)%MAX;	   //front指针后移一位 
	return 1;
}


//打印
void print(SQueue *q)
{
	while(q->front!=q->rear)
	{
		printf("%d",q->data[q->front]);
		q->front++;
	}
}


 

int main()
{
	int a,b;
	SQueue q;
	InitQueue(&q);
	EnQueue(&q,1);
	EnQueue(&q,2);
	EnQueue(&q,3);
	EnQueue(&q,4);
	DeQueue(&q,&a);
	printf("队列长度：%d",QueueLength(&q));
	printf("新队列："); 
	print(&q);
	return 0;
 } 
 

链队列

相当于尾进头出的链表

front指向头结点 非第一个结点，rear指向终端结点，即最后一个结点

结构如下：

typedef struct QNode
{
	int data;
	struct QNode *next;
}QNode,QNodePtr;

typedef struct 
{
	QNodePtr front,rear;	
}LinkQueue;

基本操作：

//初始化
LinkQueue InitQueue(LinkQueue *p)
{
	p->front=p->rear=(QNodePtr)malloc(sizeof(QNode));
	if(!p->front)
		return 0;
	p->front->next=p->front->next=NULL;
	return p;		
} 


//入队
int EnQueue(LinkQueue *q,int e)
{
	QNodePtr s=(QNodePtr)malloc(sizeof(QNode));
	s->data=e;
	s->next=NULL;
	q->rear->next=s;
	q->rear=s;    //将rear指针指向新的队尾
	return 1; 
} 


//出队
int DeQueue(LinkQueue *q,int *e)
{
	QNodePtr p;    //保存队头元素
	if(q->front==q->rear)   //队列为空
		return 0;
	p=q->front->next;
	*e=p->data;
	q->front->next=p->next;
	
	if(q->rear==p)    //队头是队尾时   删除后将rear指向头结点
		q->rear=q->front;
	free(p);	 
	return 1;
} 

测试代码：

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

//相当于尾进头出的链表
//front指向头结点 非第一个结点，rear指向终端结点，即最后一个结点

typedef struct QNode
{
	int data;
	struct QNode *next;
}QNode,*QNodePtr;

typedef struct 
{
	QNodePtr front,rear;	
}LinkQueue;



//初始化
int InitQueue(LinkQueue *p)
{
	p->front=p->rear=(QNodePtr)malloc(sizeof(QNode));
	if(!p->front)
		return 0;
	p->front->next=p->rear->next=NULL;
	return 1;			
} 



//入队
int EnQueue(LinkQueue *q,int e)
{
	QNodePtr s=(QNodePtr)malloc(sizeof(QNode));
	s->data=e;
	s->next=NULL;
	q->rear->next=s;
	q->rear=s;    //将rear指针指向新的队尾
	return 1; 
} 


//出队
int DeQueue(LinkQueue *q,int *e)
{
	QNodePtr p;    //保存队头元素
	if(q->front==q->rear)   //队列为空
		return 0;
	p=q->front->next;
	*e=p->data;
	q->front->next=p->next;
	
	if(q->rear==p)    //队头是队尾时   删除后将rear指向头结点
		q->rear=q->front;
	free(p);	 
	return 1;
} 

void print(LinkQueue q)
{
	while(q.front!=q.rear)  
	{  
		q.front=q.front->next;   //注意front指向头结点非第一个结点 故先指向下一个 
		printf("%d\n",q.front->data);
	}
}


int main()
{
	int a;
	LinkQueue q;
	InitQueue(&q);
	EnQueue(&q,1); 
	EnQueue(&q,2); 
	EnQueue(&q,3); 
	EnQueue(&q,4); 	
	DeQueue(&q,&a);
	print(q);
	return 0;
}