循环队列的基本操作

#include "com_h.H"
#include<stdio.h>
#include<iostream>
#include<cstring>
#include<string.h>
int main()
{
	SqQueue Q;
	int code;
	menu();
	while(1)
	{
		cout<<"请输入操作数字："<<endl;
		cin>>code;
		switch(code)
		{
			case 1://初始化一个空队列 
				{
					InitQueue(Q);
					cout<<"完成初始化！"<<endl;
					break; 
				}
			case 2://向队列里面输入元素 
				{
					if((Q.rear+1)%MAXQSIZE==Q.front)
					{
						cout<<"该队列已经满！"<<endl;
					 } 
					 else 
					 {
					 	QElemType e;
						cout<<"请输入元素（输入0表示结束输入）:"<<endl; 
						do{
							cin>>e;
							if(e!=0)
							{
								EnQueue (Q,e);
							}
						}while(e!=0);
						cout<<"输入结束！"<<endl;
					 }
					break;
				}
			case 3://出栈操作 
				{
					QElemType e;
					if(Q.front==Q.rear)
					{
						cout<<"无可以出栈的元素！"<<endl;
					}
					else
					{
						
						if(isEmpty(Q)==1)
						{
							cout<<"队列为空！"<<endl;
						}
						else
						{
							cout<<"出队列元素为："<<endl;
							DeQueue (Q, e);
							cout<<e<<endl;
							cout<<"出队列完成！"<<endl;
						}
					}
						break; 
				}
			case 4://判断链表是不是为空 
				{
					if(isEmpty(Q))
					{
						cout<<"队列为空！"<<endl;
					}
					else
					{
						cout<<"队列不为空！"<<endl;
					}
						break; 
				}
			case 5://获取队列的头元素 
				{
					QElemType e;	
					if(GetHead(Q,e)) 
					{
						cout<<"循环队列的头元素为："<<endl;
						cout<<e<<endl; 
					}
					else
					{
						cout<<"队为空！"<<endl;	
					}
						break; 
				}
			case 6://循环队列的长度 
				{
				int e ;
				cout<<"队列的长度为："<<endl; \
				e=QueueLength(Q);
					cout<<e<<endl;
						break; 
				}
			case 7://遍历输出元素 
				{
					if(Q.front==Q.rear)
					{
						cout<<"队列为空！"<<endl; 
					}
					else
					{
						cout<<"循环队列遍历输出为:";
						show(Q);
						cout<<endl;
					}
						break; 
				}
			case 8://销毁循环链表
				{
					DestroyQueue(Q);
					cout<<"队列摧毁完成！"<<endl; 
					break;
				}
			case 9://清空队列
				{
					if(Q.front==Q.rear)
					{
						cout<<"该队列已经为空！"<<endl; 
					}
					else
					{ 
						ClearQueue(Q); 
						cout<<"完成队列的清空操作！"<<endl; 
					}
					break; 
				}
			case 10://判断回文数
			{
				sqQueue S;
				initQueue(S); 
				char a,b,c;
				cout<<"初始化完成！"<<endl;
				char str[100];
				cout<<"请输入字符串（输入回车表示结束）："<<endl;
				getchar();
				gets(str);
				int len=strlen(str);
				for(int i=0;i<len;i++)//入队列样例 
				{
					enQueue (S, str[i]);
				}
				if(len%2==1)//输入元素为奇数个 
				{
					ElemType x;//出队列元素 
					ElemType y;//奇数个元素出队列中间元素 
					int t=len/2;
					for(int i=0;i<t;i++)
					{
						deQueue(S,x);
						enQueue (S,x);
					}
					deQueue(S,y);
				}
				int m=len/2;
				int t=m;
				for(int i=0;i<t;i++)
				{
					for(int j=0;j<m-1;j++)
					{
						deQueue(S,c);
						enQueue (S,c);
					}
					deQueue(S,a);//出队中间两个判断是否相等 
					deQueue(S,b);
					m--;
					if(a!=b)
					{
						cout<<"不是回文数！"<<endl;
						break; 
					 } 
				 } 
				 if(a==b)
					 {
					 	cout<<"是回文数！"<<endl;
					 }
			 } 
			 break;
			case 0:
				{
					cout<<"退出程序！"<<endl; 
					exit(0);
				}
			default:
				cout<<"输入错误,请重新选择输入！！"<<endl;
				break;
		 } 
	}
}

#include <stdlib.h>
#include<cstring>
#include"com_h.H"
//初始化 
Status InitQueue (SqQueue &Q) //构造一个空队列Q
{
	Q.base=new QElemType[MAXQSIZE];
	if(!Q.base) 
	{
		exit(OVERFLOW);
	}
	else
	{
		Q.front=Q.rear=0;
		return OK;
	 } 
}
//摧毁队列 
void DestroyQueue(SqQueue &Q)
{
	if(Q.base)
	{
		free(Q.base);
	 } 
	 else
	 {
	 	Q.base=NULL;
	 	Q.front=Q.rear=0;
	 }
}
//清空循环队列
void ClearQueue(SqQueue &Q) 
{
	Q.front=Q.rear;
}
//求循环队列的长度 
int QueueLength(SqQueue Q) //返回Q的元素个数， 即队列的长度
{
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}
//入队  
Status EnQueue (SqQueue &Q, QElemType e) //插入元素 e 为 Q 的新的队尾元素
{
	if((Q. rear+1) %MAXQSIZE==Q.front)//尾指针在循环意义上加1后等于头指针， 表明队满
		return ERROR; 
	Q.base[Q.rear]=e;//新元素插入队尾
	Q.rear=(Q.rear+1)%MAXQSIZE;//队尾指针加1
	return OK; 
}
//出队 
Status DeQueue (SqQueue &Q, QElemType &e) //删除Q的队头元素， 用 e 返回其值
{
	if(Q.front==Q. rear) return ERROR; //队空
	e=Q.base[Q.front]; //保存队头元素
	Q.front=(Q.front+1)%MAXQSIZE; //队头指针加1
	return OK;
}
//取队头元素 
QElemType GetHead(SqQueue Q,QElemType &e) //返回Q的队头元素，不修改队头指针
{

	if(Q.front==Q.rear)
	{
		return ERROR;
	}
	else
	{
		e=Q.base[Q.front];
		return OK;
	}
}
//判断队列是否为空
Status isEmpty(SqQueue Q) 
{
	 if(Q.front==Q.rear)//为空判断 
	 {
	 	return OK;
	 }
	 else
	 {
	 	return ERROR;
	 }
}
//判断队列是否满了
//void full(SqQueue &Q)
//{
//	//尾指针+1等于头指针，在循环意义上表示满队
//	if((Q.rear+1)%MAXQSIZE==Q.front)
//	{
//		return OK;
//	 } 
//	 else
//	 {
//	 	return ERROR;
//	 }
// } 
//遍历输出循环队列 
Status show(SqQueue Q) 
{
	int i=Q.front;
	while(Q.front!=Q.rear &&(i+MAXQSIZE)%MAXQSIZE!=Q.rear)
	{
		cout<<Q.base[i]<<" ";
		i++;
	}
	return OK;
}
//回文判断
Status initQueue (sqQueue &S)//创建一个队列 
{
	S.rear1=S.front1=0;
	return OK;
}
Status enQueue (sqQueue &S, ElemType e)//入队列 
{
	if((S.rear1+1)%maxsize == S.front1)//为满 
	{
		return ERROR;	
	}	
	else
	{
		S.data[S.rear1] = e;
		S.rear1 = (S.rear1+1)%maxsize;
		return OK;
	}
}
Status deQueue (sqQueue &S, ElemType &e)
{
	if(S.rear1 == S.front1)//为空 
	{
		return ERROR;
	}
	else
	{
		e=S.data[S.front1];
		S.front1=(S.front1+1)%maxsize;
		return OK;
	}
}
void menu()
{
	cout<<"*******************************************"<<endl;
	cout<<"***************菜单选择操作****************"<<endl; 
	cout<<"   1.初始化队列       2.输入队列元素       "<<endl;
	cout<<"   3.出栈操作         4.判断队列是不是为空 "<<endl;
	cout<<"   5.获取队头元素     6.获取循环队列长度   "<<endl;
	cout<<"   7.遍历输出元素     8.摧毁循环队列       "<<endl;
	cout<<"   9.清空循环队列     0.退出！             "<<endl;
	cout<<"   10.判断回文数（默认初始化完成！）       "<<endl;
	cout<<"                                           "<<endl; 
	cout<<"*******************************************"<<endl; 
}

#include <iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXQSIZE 5//最大循环队列长度 
#define maxsize 50

typedef int QElemType;
typedef int Status;
typedef char ElemType; 
//回文判断 

typedef struct{
	QElemType *base;//存储空间的基地址,初始化时动态分配存储空间 
	int front;//头指针
	int rear;//尾指针 
}SqQueue; 
//回文判断
typedef struct 
{
 	ElemType data[maxsize];
 	int front1,rear1;
}sqQueue;
extern void menu(); 
extern Status show(SqQueue Q);
extern void full(SqQueue Q);
extern Status isEmpty(SqQueue Q);
extern QElemType GetHead(SqQueue Q,QElemType &e);
extern Status DeQueue (SqQueue &Q, QElemType &e);
extern Status EnQueue (SqQueue &Q, QElemType e);
extern int QueueLength(SqQueue Q);
extern void ClearQueue(SqQueue &Q); 
extern void DestroyQueue(SqQueue &Q);
extern Status InitQueue (SqQueue &Q);
//回文数判断函数
extern Status initQueue (sqQueue &S);//初始化一个队列 
extern Status enQueue (sqQueue &S, ElemType e);//入栈 
extern Status deQueue (sqQueue &S, ElemType &e);//出栈 
 

循环队列可解决“假溢出"。