循环队列的操作集（C语言版）

tangguofeng

已于 2024-10-03 18:28:03 修改

阅读量743

点赞数 23

分类专栏：数据结构文章标签：数据结构 c语言

于 2024-10-02 17:47:36 首次发布

本文链接：https://blog.csdn.net/tangguofeng/article/details/142683196

版权

数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

/*
循环队列的操作集中包含的操作

   1、初始化循环队列
       Status InitQueue_Sq(SqQueue &Q, int size);
   2、销毁循环队列
       Status DestroyQueue_Sq(SqQueue &Q);
   3、判断循环队列是否为空
       Status QueueEmpty_Sq(SqQueue Q);
   4、清空循环队列
       Status ClearQueue_Sq(SqQueue &Q);
   5、入队操作
       Status EnQueue_Sq(SqQueue &Q, ElemType e);
   6、出队操作
       Status DeQueue_Sq(SqQueue &Q, ElemType &e);
   7、读取队头元素，并用 e 返回
       Status GetHead_Sq(SqQueue Q, ElemType &e);
   8、求循环队列的长度，即元素个数
       int QueueLength_Sq(SqQueue Q);
*/

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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define PERROR -2
typedef int Status;

// 数据元素的类型，使用时需根据问题的需求定义。
typedef int ElemType;

typedef struct {
ElemType *elem;       // 存储空间的基址
   int front;            // 队头位标
   int rear;           // 队尾位标，指示队尾元素的下一位置
   int maxSize;       // 存储容量
}SqQueue;

// 1、初始化循环队列
Status InitQueue_Sq(SqQueue &Q, int size){
Q.elem = (ElemType *)malloc(size * sizeof(ElemType));
if (Q.elem == NULL) return OVERFLOW; // 内存分配失败
Q.front = 0;
Q.rear = 0;
Q.maxSize = size;
return OK;
}

// 2、销毁循环队列
Status DestroyQueue_Sq(SqQueue &Q){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;       // 参数合法性检验，队已销毁
free(Q.elem);                   //释放循环队列所占的空间
Q.elem = NULL;
Q.front = 0;
Q.rear = 0;
Q.maxSize = 0;
return OK;
}

// 3、判断循环队列 S 是否为空队列
Status QueueEmpty_Sq(SqQueue Q){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;       // 参数合法性检验，队已销毁
   if(Q.front == Q.rear){
       return TRUE;
   }else{
       return FALSE;
   }
}

// 4、清空循环队列 S
Status ClearQueue_Sq(SqQueue &Q){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;       // 参数合法性检验，队已销毁
   Q.front = 0;   //将队头位标置 0
   Q.rear = 0;                       //将队尾位标置 0
   return OK;
}

// 5、入队操作
Status EnQueue_Sq(SqQueue &Q, ElemType e){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;       // 参数合法性检验，队已销毁
   // 若当前队列不满，在队尾元素之后插入新元素
if((Q.rear + 1)% Q.maxSize == Q.front) return ERROR;
Q.elem[Q.rear] = e;
Q.rear = (Q.rear + 1)% Q.maxSize;
   return OK;
}

// 6、出队操作
Status DeQueue_Sq(SqQueue &Q, ElemType &e){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;       // 参数合法性检验，队已销毁
   if(Q.front == Q.rear)return ERROR;   // 如果是空队，返回错误
   e = Q.elem[Q.front];               // 队头元素交给 e
   Q.front = (Q.front + 1)% Q.maxSize;   // 删除队头元素，改变 front 指向新的队头结点
   return OK;
}

// 7、读取队头元素，并用 e 返回
Status GetHead_Sq(SqQueue Q, ElemType &e){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;       // 参数合法性检验，队已销毁
if(Q.front == Q.rear)return ERROR;   // 如果是空队，返回错误
e = Q.elem[Q.front];               // 队头元素交给 e
return OK;
}

// 8、求循环队列的长度，即队列中的元素个数
int QueueLength_Sq(SqQueue Q){
   if((Q.elem != NULL)&&(Q.maxSize == 0))return PERROR;   // 参数合法性检验，防止实参未初始化时就使用的野指针
   if(Q.elem == NULL)return PERROR;   // 参数合法性检验，队已销毁
   return (Q.rear - Q.front + Q.maxSize) % Q.maxSize;
}

int main(){
int i, e, state;
SqQueue Q;
printf("1.初始化队列\n");
printf("2.销毁队列\n");
printf("3.判断队列是否为空\n");
printf("4.清空队列\n");
printf("5.将元素入队\n");
printf("6.队头元素出队\n");
printf("7.取队头元素，并返回\n");
printf("8.求队列中元素的个数\n");
do{
printf("请输入你要进行的操作：\n");
scanf("%d",&i);
switch(i){
case 1 :
state = InitQueue_Sq(Q, 10);
                   if(state == OK){
printf("队列初始化成功。\n");
}else{
printf("队列初始化失败！\n");
}
break;
case 2 :
state = DestroyQueue_Sq(Q);
                   if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else{
   printf("队列销毁成功。\n");
                   }
break;
case 3 :
state = QueueEmpty_Sq(Q);
                   if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else if(state == TRUE){
printf("队列为空！\n");
}else if(state == FALSE){
printf("队列不为空!\n");
}
break;
case 4 :
       state = ClearQueue_Sq(Q);
                   if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else{
   printf("已为您清空队列。\n");
                   }
break;
case 5 :
printf("请输入将要入队的元素的值：\n");
scanf("%d",&e);
state = EnQueue_Sq(Q,e);
if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else if(state == OK){
printf("元素 %d 成功入队。\n",e);
}else{
printf("元素 %d 入队失败！\n",e);
}
break;
case 6 :
       state = DeQueue_Sq(Q, e);
                   if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else if(state == OK){
printf("元素 %d 成功出队！\n",e);
}else{
printf("队列内没有元素，不能执行出队操作！\n");
}
break;
case 7 :
       state = GetHead_Sq(Q,e);
                   if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else if(state == OK){
printf("取出队头元素的值为：%d\n",e);
}else{
printf("栈内没有元素，不能执行读取队头元素操作！\n");
}
break;
case 8 :
       state = QueueLength_Sq(Q);
                   if(state == PERROR){
printf("请确认参数合法化或者先执行队列的初始化操作！\n");
}else{
printf("当前队列中元素的个数为：%d\n",state);
}
break;
}
}while(i>=1&&i<=8);
return 0;
}