考研《循环队列的代码实现》 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;
}