C语言数据结构———循环队列(静态数组实现方式)

一、队列

队列是一种先进先出操作受限的线性表结构。它只允许从队尾插入，也叫入队；只允许从队首删除，也叫出队。

二、队列分类

链式队列 —— 用链表实现的队列
顺序队列 —— 用数组实现的队列。数组可为静态数组或动态数组，顺序队列通常必须为循环队列。

注意：
循环队列是解决顺序队列内存空间利用率最大化的一种解决方案。

顺序队列

循环队列

三、队列类型定义

#define QUEUE_ZISE				6//队列长度

typedef struct Queue
{
	int qFront;//队首
	int qRear;//队尾
	int BasicArr[QUEUE_ZISE];//队列数据
}Queue, * pQueue;
//Queue  等效于 struct Queue 
//pQueue 等效于 struct Queue *

四、循环队列初始化

队首和队尾相等且为零，则已为循环队列初始阿虎。
如下图所示：

//初始化队列
void InitQueue(pQueue queue)
{
	queue->qFront = 0;
	queue->qRear  = 0;

	printf("队列初始化成功......\r\n");
	printf("队列总长度 : %d\r\n", (QUEUE_ZISE - 1));
	printf("队首 : %d\r\n", queue->qFront);
	printf("队尾 : %d\r\n", queue->qRear);
}

五、判断队列是否为空

若队首和队尾相等，则表示队列为空。当队列为空时出队无效。
如下图所示：

//队列是否为空
bool IsEmptyQueue(pQueue queue)
{
	if (queue->qFront == queue->qRear)//队首等于队尾
		return true;
	else
		return false;
}

六、判断队列是否已满

若队尾下一个数据为队首数据，则说明队列已满，当队列已满时入队无效。

注意：
队列真正使用长度为队列长度减一，这使得顺序队列内存空间利用率最大化。
如下图所示：

//队列是否为满
bool IsFullQueue(pQueue queue)
{
	//队尾下个数据为队首
	if (((queue->qRear + 1) % QUEUE_ZISE) == queue->qFront)
		return true;
	else
		return false;
}

七、循环队列数据入队

将数据存入对队尾代表的存储空间，然后队尾指向下个存储空间。

注意:
1.只允许从队尾入队(队列未满)。
2.循环队列计算下个入队存储空间为：(队尾 + 1 ) % 队列长度
如下图所示：

//入队
void EnterQueue(pQueue queue, int vale)
{
	if (IsFullQueue(queue))
	{
		printf("队列已满，入队失败......\r\n");
		return;
	}

	//从队尾入队
	queue->BasicArr[queue->qRear] = vale;//入队数据
	queue->qRear = (queue->qRear + 1) % QUEUE_ZISE;//队尾移向下个位置

	printf("入队成功！入队值为：%d   ---->    ", vale);
	printf("队首: %d   队尾: %d\r\n", queue->qFront, queue->qRear);
}

八、循环队列数据出队

将队首代表的存储空间数据输出，然后队首指向下一个存储空间。

注意:
1.只允许从队首出队(队列非空)。
2.循环队列计算下个出队存储空间为：(队出 + 1 ) % 队列长度
如下图所示：

//出队
int OutQueue(pQueue queue)
{
	int out = 0;

	if (IsEmptyQueue(queue))
	{
		printf("队列已空，出队失败......\r\n");
		return out;
	}

	out = queue->BasicArr[queue->qFront];//出队值
	queue->qFront = (queue->qFront + 1) % QUEUE_ZISE;//指向下一个出队值

	printf("出队成功！出队值为：%d   ---->    ", out);
	printf("队首: %d   队尾: %d\r\n", queue->qFront, queue->qRear);

	return  out;
}

九、显示队列数据

输出显示队列中所有数据。从队首开始直到队尾结束的所有数据。

//显示队列数据
void ShowQueue(pQueue queue)
{
	int cur = 0;

	if (IsEmptyQueue(queue))
	{
		printf("队列为空，显示失败......\r\n");
		return;
	}

	printf("队列数据: ");
	cur = queue->qFront;
	while (cur != queue->qRear)
	{
		printf("%d  ", queue->BasicArr[cur]);
		cur = (cur + 1) % QUEUE_ZISE;
	}
	printf("\r\n");
}

十、获取队列使用空间

从队首到队尾的所有数据个数为队列使用空间数。

//队列使用空间
int CountQueue(pQueue queue)
{
	int cur = 0;
	int len = 0;

	cur = queue->qFront;
	while (cur != queue->qRear)
	{
		len++;
		cur = (cur + 1) % QUEUE_ZISE;
	}

	printf("队列使用空间 : %d\r\n", len);
	return len;
}

十一、获取队列剩余空间

队列长度减一，再减去队列使用空间数，就等于列剩余空间 。即：
队列剩余空间 = 队列长度 - 1 - 队列使用空间

//队列剩余空间
int ResidueQueue(pQueue queue)
{
	int len = 0;
	int cur = 0;
	int res = 0;

	cur = queue->qFront;
	while (cur != queue->qRear)
	{
		len++;
		cur = (cur + 1) % QUEUE_ZISE;
	}

	res = QUEUE_ZISE - 1 - len;
	printf("队列剩余空间 : %d\r\n", res);
	return res;
}

十二、代码验证演示

void main(void)
{
	Queue queue;

	InitQueue(&queue);//初始化队列
	printf("\r\n");
	
	EnterQueue(&queue, 10);//入队
	EnterQueue(&queue, 20);
	EnterQueue(&queue, 30);
	EnterQueue(&queue, 40);
	EnterQueue(&queue, 50);
	CountQueue(&queue);//队列使用空间
	ResidueQueue(&queue);//队列剩余空间
	ShowQueue(&queue);//显示队列数据
	printf("\r\n");

	OutQueue(&queue);//出队
	OutQueue(&queue);
	OutQueue(&queue);
	CountQueue(&queue);//队列使用空间
	ResidueQueue(&queue);//队列剩余空间
	ShowQueue(&queue);//显示队列数据
	printf("\r\n");

	while (1);
}

十三、运行结果

队列初始化成功......
队列总长度 : 5
队首 : 0
队尾 : 0

入队成功！入队值为：10   ---->    队首: 0   队尾: 1
入队成功！入队值为：20   ---->    队首: 0   队尾: 2
入队成功！入队值为：30   ---->    队首: 0   队尾: 3
入队成功！入队值为：40   ---->    队首: 0   队尾: 4
入队成功！入队值为：50   ---->    队首: 0   队尾: 5
队列使用空间 : 5
队列剩余空间 : 0
队列数据: 10  20  30  40  50

出队成功！出队值为：10   ---->    队首: 1   队尾: 5
出队成功！出队值为：20   ---->    队首: 2   队尾: 5
出队成功！出队值为：30   ---->    队首: 3   队尾: 5
队列使用空间 : 2
队列剩余空间 : 3
队列数据: 40  50