循环队列的存储结构

CylSeqQuene.h文件

/**************************************
   文件位置：3 栈和队列\CylSeqQuene
   文件名称及类型：CylSeqQuene.h
   实现功能：循环队列的存储结构 
***************************************/

#include"..\..\1 绪论\StartDefine\StartDefine.h"

#define MAXQSIZE 100 //最大队列长度

typedef int QElemType;//循环队列类型定义 
typedef struct{
	QElemType *base;//初始化的动态分配存储空间
	int front;//头指针，若队列不空，指向队列头元素
	int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置 
}SqQueue;

//构造一个空队列
Status InitQueue(SqQueue &Q);

//队列Q被摧毁，不再存在
void DestroyQueue(SqQueue &Q);

//将Q清为空队列
Status ClearQueue(SqQueue &Q);

//判断队列是否为空，是的话返回TRUE，否则返回FALSE
Status QueueEmpty(SqQueue Q);

//返回队列的元素个数，即队列长度
int QueueLength(SqQueue Q);

//用e返回Q的队头元素
Status GetHead(SqQueue Q,QElemType &e);
 
 //插入元素e为新的队尾元素
Status EnQueue(SqQueue &Q,QElemType e);

//删除Q的队头元素，并用e返回其值 
Status DeQueue(SqQueue &Q,QElemType &e);

//从队头到队尾，依次对Q中的数据元素调用函数visit()，一旦visit()失败，则操作失败 
void QueueTraverse(SqQueue Q,void(*visit)(QElemType));

CylSeqQuene.cpp文件

/**************************************
   文件位置：3 栈和队列\CylSeqQuene
   文件名称及类型：CylSeqQuene.cpp 
   实现功能：循环队列的存储结构的实现 
***************************************/

#include"CylSeqQueue.h"

//构造一个空队列
Status InitQueue(SqQueue &Q){
	Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
	if(!Q.base) exit(OVERFLOW);//存储分配失败
	Q.front=Q.rear=0;
	return OK;
} 

//队列Q被摧毁，不再存在
void DestroyQueue(SqQueue &Q){
	if(Q.base)
	free(Q.base);
	
	Q.base=NULL;
	Q.front=Q.rear=0;
}

//将Q清为空队列
Status ClearQueue(SqQueue &Q){
	Q.front=Q.rear=0;
}

//判断队列是否为空，是的话返回TRUE，否则返回FALSE
Status QueueEmpty(SqQueue Q){
	if(Q.front==Q.rear)
	return TRUE;
	else
	return ERROR;
}

//返回队列的元素个数，即队列长度
int QueueLength(SqQueue Q){
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

//用e返回Q的队头元素
Status GetHead(SqQueue Q,QElemType &e){
	if(Q.front==Q.rear)
	return ERROR;
	e=Q.base[Q.front];
	return OK;
}
 
 //插入元素e为新的队尾元素
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;
}

//删除Q的队头元素，并用e返回其值 
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中的数据元素调用函数visit()，一旦visit()失败，则操作失败 
void QueueTraverse(SqQueue Q,void(*visit)(QElemType)){
	int i=Q.front;
	while(i!=Q.rear){
		visit(Q.base[i]);
		i=(i+1)%MAXQSIZE;
	}
}

CylSeqQuene-Test.cpp文件

/**************************************
   文件位置：3 栈和队列\CylSeqQuene
   文件名称及类型：CylSeqQuene-Test.cpp 
   实现功能：循环队列的存储结构的测试 
***************************************/

#include"CylSeqQueue.cpp"

int main(){
	SqQueue Q;
	int i;
	QElemType e;
	void PrintElem(QElemType e);
	
	printf("函数InitQueue测试...\n");
	printf("初始化循环队列...");
	InitQueue(Q);
	printf("\n");
	
	printf("函数QueueEmpty测试...\n");
	QueueEmpty(Q)?printf("循环队列为空\n"):printf("循环队列不为空");
	
	printf("函数EnQueue测试...\n");
	for(int i=1;i<=6;i++){
		printf("将%d插入到队列Q...",2*i);
		EnQueue(Q,2*i);
		printf("累计插入%d个元素\n",(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE);
	}
	printf("\n");
	
	printf("函数QueueTraverse测试...\n");
	QueueTraverse(Q,PrintElem);
	printf("\n");
	
	printf("函数QueueLength测试...\n");
	printf("队列中元素的个数为%d\n",QueueLength(Q));
	
	printf("函数DeQueue测试...\n");
	DeQueue(Q,e);
	printf("删除的元素为%d\n",e);
	GetHead(Q,e);
	printf("此时队列头的元素为%d\n",e); 
	
	printf("函数ClearQueue测试...\n");
	ClearQueue(Q);
	QueueEmpty(Q)?printf("循环队列为空\n"):printf("循环队列不为空");
	
	printf("函数DestroyQueue测试...\n");
	DestroyQueue(Q);
	Q.base==NULL?printf("循环队列已不存在\n"):printf("循环队列还存在");
}

//定义输出函数
void PrintElem(QElemType e){
	printf("%d ",e);
}

循环队列的存储结构

猜你喜欢