考研《循环队列的代码实现》 rear指针指向队尾元素的后一个位置的代码实现 且包含三种判断队列为空为满的方法

考研《循环队列的代码实现》 rear指针指向队尾元素的后一个位置的代码实现 且包含三种判断队列为空为满的方法

这个代码主要写了队列的顺序存储------ 循环队列
队头指针指向队头元素 Q.front = 0
队尾指针指向队尾元素的下一个位置 Q.rear = 0
所实现的功能:
1. 初始化
2. 判断队列为空，为满(3种情况)
a. 牺牲一个存储单元
b. 增加size变量
c. 增加tag变量
3. 入队
4. 出队
5. 队列顺序存储的存储类型
6. 计算队列长度

代码：

注释写的很清晰，大家仔细观看

/*
   这个代码主要写了队列的顺序存储------ 循环队列
   队头指针指向队头元素 Q.front = 0
   队尾指针指向队尾元素的下一个位置 Q.rear = 0
   所实现的功能:
        1. 初始化
        2. 判断队列为空，为满(3种情况)
            a. 牺牲一个存储单元
            b. 增加size变量
            c. 增加tag变量
        3. 入队
        4. 出队
        5. 队列顺序存储的存储类型
        6. 计算队列长度
*/
#include <stdio.h>

#define MaxSize 5
typedef int ElemType;

// 定义牺牲一个存储单元 的结构体定义
typedef struct {
  ElemType data[MaxSize];
  int front, rear;
} Squeue;

// 初始化0 -- 牺牲一个存储单元
void InitQueue0(Squeue &Q) { Q.front = Q.rear = 0; }

// 判断队列为空0 -- 牺牲一个存储单元
bool isEmpty0(Squeue Q) { return Q.rear == Q.front; }

// 判断队列为满0 -- 牺牲一个存储单元
bool QueueFull0(Squeue Q) {
  if ((Q.rear + 1) % MaxSize == Q.front)
    return true;
  else
    return false;
}
// 计算队列长度0 -- 牺牲一个存储单元
int QueueLength0(Squeue Q) { return (Q.rear - Q.front + MaxSize) % MaxSize; }

// 入队0 -- 牺牲一个存储单元
bool EnQueue0(Squeue &Q, ElemType x) {
  // 如果队列满了
  if ((Q.rear + 1) % MaxSize == Q.front)
    return false;
  Q.data[Q.rear] = x;
  Q.rear = (Q.rear + 1) % MaxSize;
  return true;
}
// 出队0 --牺牲一个存储单元
bool DeQueue0(Squeue &Q, ElemType &x) {
  // 如果队列为空
  if (Q.rear == Q.front)
    return false;
  x = Q.data[Q.front];
  Q.front = (Q.front + 1) % MaxSize;
  return true;
}

//------------------------------增加size变量记录队列长度--------------------------------------

typedef struct {
  ElemType data[MaxSize];
  int rear, front, size;
} Squeue1;

// 初始化 -- 增加size变量记录队列长度
void InitQueue1(Squeue1 &Q) {
  Q.rear = Q.front = 0;
  Q.size = 0;
}
// 判断队列为空0 -- 增加size变量记录队列长度
bool QueueEmpty1(Squeue1 Q) {
  if (Q.size == 0)
    return true;
  else
    return false;
}
// 判断队列为满1 -- 增加size变量记录队列长度
bool QueueFull1(Squeue1 Q) {
  if (Q.size == MaxSize)
    return true;
  else
    return false;
}
// 计算队列长度1 -- 增加size变量记录队列长度
int QueueLength1(Squeue1 Q) { return Q.size; }
// 入队1 --增加size变量记录队列长度
bool EnQueue1(Squeue1 &Q, ElemType x) {
  if (Q.size == MaxSize)
    return false;
  Q.data[Q.rear] = x;
  Q.rear = (Q.rear + 1) % MaxSize;
  Q.size++;
  return true;
}
// 出队1 --增加size变量记录队列长度
bool DeQueue1(Squeue1 &Q, ElemType &x) {
  if (Q.size == 0)
    return false;
  x = Q.data[Q.front];
  Q.front = (Q.front + 1) % MaxSize;
  Q.size--;
  return true;
}

//------------------------------增加tag变量标志--------------------------------------

/*
   这里我们需要注意
   每当删除一个元素的时候，tag设置为0，因为队列为空的时候，必定是删除
   元素之后，才可能为空
   每当增加一个元素的时候，tag设置为1，因为队列为满的时候，必定是增加了
   元素之后，才可能为满
*/

typedef struct {
  ElemType data[MaxSize];
  int front, rear;
  int tag;
} Squeue2;

// 初始化2 --增加tag变量
void InitQueue2(Squeue2 &Q) {
  Q.rear = Q.front = 0;
  Q.tag = 0;
}

// 判断队列为空2  --增加tag变量
bool isEmpty2(Squeue2 Q) {
  if (Q.rear == Q.front && Q.tag == 0)
    return true;
  else
    return false;
}

// 判断队列为满2 -- 增加tag变量
bool QueueFull2(Squeue2 Q) {
  if (Q.rear == Q.front && Q.tag == 1)
    return true;
  else
    return false;
}

// 计算队列长度2 -- 增加tag变量
int QueueLength2(Squeue2 Q) { return Q.rear - Q.front + MaxSize; }

// 入队2 --增加tag变量
bool EnQueue2(Squeue2 &Q, ElemType x) {
  if (Q.rear == Q.front && Q.tag == 1)
    return false;
  Q.data[Q.rear] = x;
  Q.rear = (Q.rear + 1) % MaxSize;
  Q.tag = 1;
  return true;
}

// 出队2 --增加tag变量
bool DeQueue2(Squeue2 &Q, ElemType &x) {
  if (Q.rear == Q.front && Q.tag == 0)
    return false;
  x = Q.data[Q.front];
  Q.front = (Q.front + 1) % MaxSize;
  Q.tag = 0;
  return true;
}