队列基本操作代码实现（循环队列）

首先了解一下队列，队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
假如我们以顺序存储方式创建此队列，以malloc（）函数申请100个连续的内存块区域，假如我们入队100个元素之后，再执行出队80个，那么此时对头指针front指向第100个元素的地址，rear指针指向第80个元素的地址，那么此时如果再次执行入队操作，front指针++后便会return error，会认为此时空间已满，因为malloc申请的内存块大小只有100，但实际上有80个内存空间已经腾出来了，还没有使用。那么就要引入循环队列来解决。

主要操作为每次出队和入队：Q.front=（Q.front+1）%MAXQSIZE，Q.rear=（Q.rear+1）%MAXQSIZE。

这样的话入队和出队就变成rear和front相互追逐的过程，那么假如rear= =front，此时到底是队列满了还是为空呢？所以我们专门另最后一个内存区域不存放数据，而是用来鉴别队列满或空。入队时rear++，出队时front++，假若（rear+1）%MAXQSIZE= =front,那么此时队列满，而如果出队后front++导致front==rear，那么此时队列为空。

代码及具体细节如下：

#include<iostream>
#include<stdlib.h>
#define MAXQSIZE 5
using namespace std;
#define TRUE 1
#define FALSE 0

typedef struct
{
	int *base;
	int front;
	int rear;
}SqQueue;

int InitQueue(SqQueue &Q)//创建队列 
{
	Q.base=(int *)malloc(MAXQSIZE * sizeof(int));
	if(!Q.base)		return FALSE; 
	Q.front=0;
	Q.rear=0;
	return TRUE;
}

int DestroyQueue(SqQueue &Q)
{
	if(Q.base)
	{
		free(Q.base);//释放内存 
		Q.base=NULL;//指针指向空 
		Q.front=Q.rear=0;
		return TRUE;
	}	 
	else	return FALSE;
}

int ClearQueue(SqQueue &Q)
{
	while(Q.base[Q.front])
	{
		Q.base[Q.front]=0;
		Q.front=(Q.front+1)%MAXQSIZE;
	}
	Q.front=Q.rear=0;
	return TRUE;
}

int QueueEmpty(SqQueue &Q)//当插入元素时，rear还有一个位置就要和front碰头，就认为队列已满，不对这个位置进行操作。 
{						  //删除元素时，front追上rear，front==rear时即为队列为空，但不一定为0 
	if(Q.front==Q.rear)   //所以rear==front,队列为空	(rear+1)%MAXQSIZE==front,队列满 
	return TRUE;
	return FALSE;
}

int QueueLength(SqQueue &Q)
{
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
} 

int GetHead(SqQueue &Q,int &e)//形参要加& 
{
	
	if(!QueueEmpty(Q))
	{
		e=Q.base[Q.front];
		return TRUE;
	}
	else	return FALSE;
 } 
 
void EnQueue(SqQueue &Q,int e)
{
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXQSIZE;
}

//形参e要加上&，因为要把赋值后的e传给main函数。 
void DeQueue(SqQueue &Q,int &e)
{
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXQSIZE;
}

void TraverseQueue(SqQueue &Q)
{
		int j=Q.front;		//j用来指示Q.base[j]
		for(int i=Q.front;i<Q.front+QueueLength(Q);i++,j=(j+1)%MAXQSIZE)//i表示循环次数 
		{
			cout<<Q.base[j]<<" ";
		}
		cout<<endl;
}

int main()
{
	cout<<"队列最大长度为4，插入4个元素让队列满之后，可以体现循环功能"<<endl; 
	SqQueue Q;
	int e;
	int flag;//用来体现循环队列 
	char index;
	
	if(InitQueue(Q))	cout<<"Creat Queue successfully!"<<endl;
	else	cout<<"Creat failed!"<<endl;
	
	//插入操作时，main函数里要先cin>>e.再调用函数。 
	while(1)
	{
		if((Q.rear+1)%MAXQSIZE==Q.front)
		{
			cout<<"Error!the queue is full"<<endl;
			flag=1;//如果队列插入满的话，对头删除后对尾可以继续插入，体现循环 
			break;
		}	
		cout<<"Input a number you want to insert:";
		cin>>e;
		EnQueue(Q,e);
		cout<<"Queue:";
		TraverseQueue(Q);
		cout<<"Continue inserting?   Y or N :";
		cin>>index;
		if(index!='Y'&&index!='y')		break;
	}
	
	//删除
	while(1)
	{
		if(Q.front==Q.rear)	
		{
			cout<<"Error!the queue is empty"<<endl;
			break;
		}
		DeQueue(Q,e);	
		cout<<"Pop the front:"<<e<<endl;
		cout<<"Queue:";
		TraverseQueue(Q);
		cout<<"Continue deleting?   Y or N :";
		cin>>index;
		if(index!='Y'&&index!='y')	  break;
	 }
	 
	 //循环 
	 if(flag)
	 {
	 	cout<<"此次插入为了体现循环：因之前队列已满，删除对头元素后，对尾可以继续插入"<<endl;
		while(1)
		{
			if((Q.rear+1)%MAXQSIZE==Q.front)
			{
				cout<<"Error!the queue is full"<<endl;
				flag=1;//如果队列插入满的话，对头删除后对尾可以继续插入，体现循环 
				break;
			}	
			cout<<"Input a number you want to insert:";
			cin>>e;
			EnQueue(Q,e);
			cout<<"Queue:";
			TraverseQueue(Q);
			cout<<"Continue inserting?   Y or N :";
			cin>>index;
			if(index!='Y'&&index!='y')		break;
		}
	} 
	 
	if(GetHead(Q,e)==FALSE)		cout<<"Error!the queue is empty"<<endl;
	else	cout<<"The head of queue:"<<e<<endl;
	
	cout<<"The length of queue:"<<QueueLength(Q)<<endl;

	if(QueueEmpty(Q))	cout<<"The queue is Empty"<<endl;
	else	cout<<"the queue isn't empty"<<endl;
	
	if(ClearQueue(Q))	cout<<"Clear successfilly!"<<endl; 
	
	if(DestroyQueue(Q))	cout<<"Destroy successflully!"<<endl;
	else	cout<<"Error!"<<endl;
}