数据结构——循环队列的实现

---

前言

前面我们已经学习过队列的相关知识和代码实现，当时我们是用链表实现的队列。至于我们为什么没用顺序表，我们也进行了详细的解释，也画了一张图进行说明其中的原由。实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现

---

一、什么是循环队列？

队列的定义：为充分利用向量空间，克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表或数组的方式来在实际编程应用中来实现。
如图所示：

二、循环队列的实现

1.各个模块的功能

代码如下:

#define K 5//定义一个常量
typedef int CQDataType;//对循环队列中的数据类型进行重定义

typedef struct CirculationQueue
{
	CQDataType* a;
	int front;//用于存放队头的位置
	int tail;//存放队尾的位置
	int k;//队列中的容量
}CQ;

//循环队列的初始化
void CirculationQueueInit(CQ* cq);
//打印循环队列中的数据
void  CirculationQueuePrint(CQ* cq);
//获取队头的数据
CQDataType CirculationQueueFront(CQ* cq);
//获取队尾的数据
CQDataType CirculationQueueTail(CQ* cq);
//插入
void CirculationQueuePush(CQ* cq, CQDataType x);
//删除
void CirculationQueuePop(CQ* cq);
//判断队列是否为空
bool CirculationQueueEmpty(CQ* cq);
//判断队列是否为满
bool CirculationQueueFull(CQ* cq);
//获取队列的有效元素的个数
int CirculationQueueSize(CQ* cq);
//释放队列
void CirculationQueueFree(CQ* cq);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2.功能的实现

代码如下：

//循环队列的初始化
void CirculationQueueInit(CQ* cq)
{
	cq->k = K;
	cq->front = cq->tail = 0;
	cq->a = (CQDataType*)malloc(sizeof(CQDataType)*(cq->k + 1));
}
//打印循环队列中的数据
void  CirculationQueuePrint(CQ* cq)
{
	int cur = cq->front;//定义一个cur变量，指向front
	while (cur != cq->tail)//如果cur和tail相等，则表示队列已经到尾了(队列可能为空)
	{
		printf("%d ", cq->a[cur]);
		cur = (cur + 1) % (cq->k + 1);//在画图分析中细说
	}
	printf("\n");
}

//获取队头的数据
CQDataType CirculationQueueFront(CQ* cq)
{
	assert(cq);
	assert(!CirculationQueueEmpty(cq));//获取队头数据需要判断队列是否为空
	return cq->a[cq->front];//直接返回队头的数据
}
//获取队尾的数据
CQDataType CirculationQueueTail(CQ* cq)
{
	assert(cq);
	assert(!CirculationQueueEmpty(cq));//获取队尾数据也需要判断队列是否为空
	if (cq->tail == 0)//这里有两种情况，第一种当tail为0时，表示tail的前一个存放着有效数据
	{                 //也就是数组中的最后一个位置
		return cq->a[cq->k];
	}
	return cq->a[cq->tail - 1];//第二种，如果tail不为0，则tail-1的位置存放着最后一个数据
}
//插入
void CirculationQueuePush(CQ* cq, CQDataType x)
{
	assert(cq);
	assert(!CirculationQueueFull(cq));//因为循环队列的容量是有限的，所以插入数据时需要先判断队列是否已满
	cq->a[cq->tail] = x;//tail位置为空，所以直接存放数据
	cq->tail = (cq->tail + 1) % (cq->k + 1);
}
//删除
void CirculationQueuePop(CQ* cq)
{
	assert(cq);
	assert(!CirculationQueueEmpty(cq));//删除数据时，也需要判断队列是否为空
	cq->front = (cq->front + 1) % (cq->k + 1);
}
//判断队列是否为空
bool CirculationQueueEmpty(CQ* cq)
{
	assert(cq);
	return cq->front == cq->tail;//如果队列为空，则front和tail肯定都为0，因为这循环队列的特性
}
//判断队列是否为满
bool CirculationQueueFull(CQ* cq)
{
	assert(cq);
	return (cq->tail + 1) % (cq->k + 1) == cq->front;//判断tail+1的位置是否和front相等
}
//获取队列的有效元素的个数
int CirculationQueueSize(CQ* cq)
{
	assert(cq);
	return (cq->tail - cq->front + cq->k + 1) % (cq->k + 1);
}
//释放队列
void CirculationQueueFree(CQ* cq)
{
	assert(cq);
	if (cq->a)
	{
		free(cq->a);
	}
	cq = NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

画图分析：

3.程序测试

代码如下：

void test()
{
	CQ q;
	CirculationQueueInit(&q);
	CirculationQueuePush(&q, 1);
	CirculationQueuePush(&q, 2);
	CirculationQueuePush(&q, 3);
	CirculationQueuePush(&q, 4);
	CirculationQueuePrint(&q);
	printf("队头:%d\n", CirculationQueueFront(&q));
	CirculationQueuePop(&q);
	CirculationQueuePop(&q);
	CirculationQueuePrint(&q);
	printf("队尾:%d\n", CirculationQueueTail(&q));
	CirculationQueuePop(&q);
	CirculationQueuePush(&q, 7);
	CirculationQueuePush(&q, 8);
	CirculationQueuePrint(&q);
	printf("队列中的有效数据个数:%d\n", CirculationQueueSize(&q));
	CirculationQueueFree(&q);
}

int main()
{
	test();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

测试：

三、总结

这次我们学习了循环队列，并用数组的方式加以实现。在学习的过程中我们发现，虽然被称为是循环队列，但其实数组并不是循环的，只是我们用了一个取余(模)操作来实现循环的过程。除此之外，我们还了解了为何开辟数组时，需要多开辟一个容量的空间，这也是导致判空和判满的功能实现是大相庭径的。