【数据结构与算法】详解循环队列：基于数组实现高效存储与访问

倔强的石头_

于 2024-06-24 00:05:56 发布

阅读量1.3k

点赞数 98

分类专栏：数据结构与算法文章标签：算法数据结构 c语言

本文链接：https://blog.csdn.net/2302_78391795/article/details/139578914

版权

数据结构与算法专栏收录该内容

16 篇文章 2 订阅

订阅专栏

            💓 博客主页：倔强的石头的CSDN主页

           📝Gitee主页：倔强的石头的gitee主页

⏩ 文章专栏：《数据结构与算法》

    期待您的关注

🍃Circular_Queue.h //循环队列头文件

🍃Circular_Queue.c //循环队列源文件

一、引言

🍃队列的概念

队列（Queue）是一种常见的数据结构，它遵循先进先出（FIFO）的原则，即最早进入队列的元素将最先被移除。队列在计算机科学中有广泛的应用，比如任务调度、网络流量控制、打印任务管理等。然而，当我们在处理固定大小的空间时，传统的队列实现可能会遇到空间浪费的问题。为了解决这个问题，我们引入了循环队列（Circular Queue）的概念。

关于队列的详细介绍，请参考前置文章

【数据结构与算法】使用单链表实现队列：原理、步骤与应用-CSDN博客

🍃循环队列的概念

循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。相比于传统的队列实现，循环队列能够更有效地利用存储空间，并在数组大小固定的情况下实现队列的无限循环。在本文中，我们将详细探讨如何使用数组来实现循环队列，并分析其优势和应用场景。

🍃为什么使用数组实现循环队列

循环队列的实现方式主要是基于数组的，但也可以采用其他数据结构，如链表。不过，在实际应用中，数组实现循环队列的方式更为常见和高效。

基于数组实现循环队列的特点和优势：

空间利用率高：通过将数组的最后一个位置与第一个位置相连，循环队列能够充分利用数组的存储空间，避免传统队列在多次入队和出队操作后可能出现的空间浪费现象。
操作简便：在数组实现中，可以通过简单的数学运算（如取模运算）来更新头指针和尾指针，实现入队和出队操作。这使得循环队列的操作非常简便和高效。
时间复杂度低：无论是入队还是出队操作，循环队列的时间复杂度都是O(1)，即常数时间复杂度。这意味着无论队列中有多少元素，入队和出队操作所需的时间都是固定的。

循环队列在逻辑上的结构是这样的

但在物理上的结构是这样的

二、循环队列的结构定义

包含

指向数组的指针，这是循环队列的底层结构
指向队首和队尾的整型变量front和rear
循环队列的空间大小k

typedef int CQueueDataType;
typedef struct MyCircularQueue//循环队列结构定义
{
	CQueueDataType* a;
	int front;
	int rear;
	int k;
} MyCircularQueue;

三、循环队列的接口实现

🍃队列初始化

动态开辟一块循环队列结构体大小的空间
为数组指针的指向地址分配一块动态申请的内存，大小为k+1个空间，但实际使用k个（不申请k个是为了区别队列空和队列满，保留一个空间）
front和rear初始为0（要注意rear初始为0，意味着指向的是队尾的下一个元素）
k初始化为输入的值
最后返回该队列的地址

MyCircularQueue* myCircularQueueCreate(int k) //循环队列初始化
{
	MyCircularQueue* tmp = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	tmp->a = (CQueueDataType*)malloc(sizeof(CQueueDataType) * (k + 1));
	tmp->front = tmp->rear = 0;
	tmp->k = k;
	return tmp;
}

🍃入队列

首先对形参接收的地址判空
然后判断队列是否满
如果有空间可用的话，在rear指向的位置插入数据
调整rear的位置，向后移动注意考虑循环的问题（rear+1）%（k+1），先对rear+1再对数组长度取模

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) //入队列
{
	assert(obj);
	if (myCircularQueueIsFull(obj))
		return false;
	obj->a[obj->rear] = value;
	obj->rear = (obj->rear + 1) % (obj->k + 1);
	return true;
}

🍃出队列

首先对形参接收的地址判空
然后判断队列是否为空
如果有数据可出的话，直接调整front的位置即可（不过应当考虑循环值溢出的问题）（front+1)%（k+1）
先对front+1再对数组长度取模

bool myCircularQueueDeQueue(MyCircularQueue* obj) //出队列
{
	assert(obj);
	if (myCircularQueueIsEmpty(obj))
		return false;
	obj->front = (obj->front + 1) % (obj->k + 1);
	return true;
}

🍃取队首元素

首先对形参接收的地址判空
然后判断队列是否为空（空队列无数据可取）
然后返回front位置的元素即可

int myCircularQueueFront(MyCircularQueue* obj) //取队首元素
{
	assert(obj);
	if (myCircularQueueIsEmpty(obj))
		return -1;
	return obj->a[obj->front];
}

🍃取队尾元素

首先对形参接收的地址判空
然后判断队列是否为空（空队列无数据可取）
队尾元素是rear位置的前一个元素，考虑到直接-1可能会出错，正确的位置应该是（rear - 1 + k + 1) % (k + 1)，也可以简化成（rear +k ) % (k + 1)
返回该位置数据即可

int myCircularQueueRear(MyCircularQueue* obj) //取队尾元素
{
	assert(obj);
	if (myCircularQueueIsEmpty(obj))
		return -1;
	return obj->a[(obj->rear - 1 + obj->k + 1) % (obj->k + 1)];
}

🍃判空

对形参接收的地址判空
然后返回front==rear的结果

bool myCircularQueueIsEmpty(MyCircularQueue* obj) //判空
{
	assert(obj);
	return obj->front == obj->rear;
}

🍃判满

对形参接收的地址判空
队列满的条件理应是rear+1==front，但考虑到队列是一个"环形"的，要考虑值的溢出，所以改为（rear + 1 )% （k +1)==front

bool myCircularQueueIsFull(MyCircularQueue* obj) //判满
{
	assert(obj);
	return (obj->rear + 1) % (obj->k + 1)==(obj->front);
}