循环队列的顺序存储

一、什么是队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列为先进先出（First In First Out），简称 FIFO 的数据结构。

队列示意图

二、各个功能实现

（一）初始化

1、算法步骤

（1）队列的最大容量初始化为 $maxSize$
（2）为队列申请一块大小为 $maxSize\ast sizeof(ElemType)$ 的连续存储空间
（3）令 $front$ 与 $rear$ 同时为 $0$ ，表示空队列

2、算法代码

// 初始化一个最大容量为 maxSize 的空队列
void Create(Queue* queue, int maxSize)
{
	queue->maxSize = maxSize;
	queue->element = (ElemType*)malloc(maxSize * sizeof(ElemType));
	queue->front = queue->rear = 0;	// 队首与队尾同时为0，表示空队列
}

空队列示意图

（二）清空队列

1、算法步骤

（1）令 $front$ 与 $rear$ 同时为 $0$ ，表示空队列

2、算法代码

// 清空一个队列，但不释放存储空间
void Clear(Queue* queue)
{
	queue->front = queue->rear = 0;	// 队首与队尾同时为0，表示空队列
}

（三）销毁队列

1、算法步骤

（1）队列的大小 $maxSize$ 置 $0$
（2）释放申请的动态空间
（3）令 $front$ 与 $rear$ 同时为 $-1$ ，表示队列销毁

2、算法代码

// 销毁一个队列，并释放存储空间
void Destory(Queue* queue)
{
	queue->maxSize = 0;
	free(queue->element);
	queue->front = queue->rear = -1;
}

（四）判断队列是否为空

1、算法步骤

（1）如果队列的 $front$ 与 $rear$ 相等，则队列为空

2、算法代码

// 判断队列是否为空
int IsEmpty(Queue* queue)
{
	return queue->front == queue->rear;
}

（五）判断队列是否为满

1、算法步骤

（1）如果队列的 $(rear+1)\%maxSize$ 与 $front$ 相等，则队列为满

2、算法代码

// 判断队列是否为满
int IsFull(Queue* queue)
{
	return (queue->rear + 1) % (queue->maxSize) == queue->front;
}

（六）返回队首元素

1、算法步骤
（1）判断队列是否为空
（2）返回队首元素，队首元素的索引为 $(front+1)\%maxSize$

2、算法代码

// 返回队首元素
ElemType GetFront(Queue* queue)
{
	if (IsEmpty(queue))
	{
		return Error;
	}
	return queue->element[(queue->front + 1) % (queue->maxSize)];
}

（七）队尾入队

1、算法步骤

（1）判断队列是否已满
（2）$rear++$
（3）在队尾插入元素

2、算法代码

// 队尾入队（rear + 1）
void EnQueue(Queue* queue, ElemType x)
{
	if (IsFull(queue))
	{
		return Error;
	}
	queue->rear = (queue->rear + 1) % queue->maxSize;
	queue->element[queue->rear] = x;
	printf("调用了 EnQueue(%d) 函数\n", x);
}

入队列示意图

（八）队首出队

1、算法步骤

（1）判断队列是否为空
（2）$front++$

2、算法代码

// 队首出队（front + 1）
void DeQueue(Queue* queue)
{
	if (IsEmpty(queue))
	{
		return Error;
	}
	queue->front = (queue->front + 1) % queue->maxSize;
	printf("调用了 DeQueue() 函数\n");
}

出队列示意图

（九）打印队列全部元素

1、算法步骤
（1）找到 $front$ 和 $rear$ 依次打印即可

2、算法代码

// 打印队列的全部元素
void PrintQueue(Queue* queue)
{
	printf("调用了 PrintQueue() 函数\n");
	if (IsEmpty(queue))
	{
		return Error;
	}
	int front = queue->front;
	int rear = queue->rear;
	int i = 0;
	for (i = front + 1; i < rear; i++)
	{
		printf("%d <- ", queue->element[i]);
	}
	// 为了输出美观，特殊处理打印最后一个元素
	printf("%d\n\n", queue->element[i]);
}

入队列示意图

三、全部代码

#include <stdio.h>
#define ElemType int
#define Error 0
#define OK 1
typedef int Status;

// 队列结构体
typedef struct queue
{
	int front;
	int rear;
	int maxSize;
	ElemType* element;
}Queue;

// 初始化一个最大容量为 maxSize 的空队列
void Create(Queue* queue, int maxSize)
{
	queue->maxSize = maxSize;
	queue->element = (ElemType*)malloc(maxSize * sizeof(ElemType));
	queue->front = queue->rear = 0;	// 队首与队尾同时为0，表示空队列
}

// 清空一个队列，但不释放存储空间
void Clear(Queue* queue)
{
	queue->front = queue->rear = 0;	// 队首与队尾同时为0，表示空队列
}


// 销毁一个队列，并释放存储空间
void Destory(Queue* queue)
{
	queue->maxSize = 0;
	free(queue->element);
	queue->front = queue->rear = -1;
}

// 判断队列是否为空
int IsEmpty(Queue* queue)
{
	return queue->front == queue->rear;
}

// 判断队列是否为满
int IsFull(Queue* queue)
{
	return (queue->rear + 1) % (queue->maxSize) == queue->front;
}

// 返回队首元素
ElemType GetFront(Queue* queue)
{
	if (IsEmpty(queue))
	{
		return Error;
	}
	return queue->element[(queue->front + 1) % (queue->maxSize)];
}

// 队尾入队（rear + 1）
void EnQueue(Queue* queue, ElemType x)
{
	if (IsFull(queue))
	{
		return Error;
	}
	queue->rear = (queue->rear + 1) % queue->maxSize;
	queue->element[queue->rear] = x;
	printf("调用了 EnQueue(%d) 函数\n", x);
}

// 队首出队（front + 1）
void DeQueue(Queue* queue)
{
	if (IsEmpty(queue))
	{
		return Error;
	}
	queue->front = (queue->front + 1) % queue->maxSize;
	printf("调用了 DeQueue() 函数\n");
}

// 打印队列的全部元素
void PrintQueue(Queue* queue)
{
	printf("调用了 PrintQueue() 函数\n");
	if (IsEmpty(queue))
	{
		return Error;
	}
	int front = queue->front;
	int rear = queue->rear;
	int i = 0;
	for (i = front + 1; i < rear; i++)
	{
		printf("%d <- ", queue->element[i]);
	}
	// 为了输出美观，特殊处理打印最后一个元素
	printf("%d\n\n", queue->element[i]);

}

int main()
{
	Queue* queue = malloc(sizeof(Queue));
	Create(queue, 10);

	EnQueue(queue, 0);
	EnQueue(queue, 1);
	EnQueue(queue, 2);
	EnQueue(queue, 3);
	PrintQueue(queue);

	DeQueue(queue);
	PrintQueue(queue);

	EnQueue(queue, 100);
	PrintQueue(queue);

	return 0;
}