关于 C++ 队列算法，你该了解这些【第四集：循环队列】

最新推荐文章于 2024-05-09 09:14:58 发布
最新推荐文章于 2024-05-09 09:14:58 发布
阅读量473 收藏 2
点赞数 2
分类专栏： 算法 文章标签： 队列 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp_learner/article/details/105295221
版权

上集回顾：线性池中的任务队列

第一集：顺序存储队列
第二集：链式存储队列
第三集：线性池中的任务队列

观看本系列博文提醒：
你将学会队列的两种最基本的表现形式：顺序存储队列 和 链式存储队列；
一个扩展队列的使用方法：循环队列；
两个企业级队列的应用：线性池中的任务队列 和 优先链式存储队列。

队列的原理

队列是一种受限的线性表，(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out).
在这里插入图片描述
例如上图中，圆球1先进，也是圆球1先出。

队列是一种受限的线性结构

  1. 它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。
  2. 生活中队列场景随处可见: 比如在电影院, 商场, 或者厕所排队。。。。。。
    在这里插入图片描述
    由上图我们可以知道，队列中有两个“指针”，front指向队首，rear指向队尾；
    至于length，他是整个队列的总长度（因为一个队列他是有固定长度的）。

循环队列

我们现在来回顾一下第一集中的内容。我们知道，顺序存储队列有两种出队的方式 。当我们采用第二种方式出队时，队列中的存储空间会越来越小直至内存都没耗光。这样可以避免元素移动，但是也带来了一个新的问题“假溢出”。
在这里插入图片描述
那么，能否利用前面的空间继续存储入队呢？
答案是可以的。所以我们有了现在的循环队列。
让我们现在开始学习吧！

原理精讲

在开始码代码之前，我们得先了他的原理。

何为循环队列呢。就是当有元素出队后，可以重复利用前面已经出队的内存空间。在这里插入图片描述

如上图。队列之前出队的元素所占的空间可以重复利用。

所以我们可以重复的在之前的内存中插入元素，直到队列满为止。
当然使用循环队列，当队列满时，尾“指针”和头“指针”必须空开一个元素的位置，这样做有利于方便做队列已满的判断！如下图。
在这里插入图片描述
可能有朋友会问，那为什么不把头“指针”front 和 尾“指针”rear 相等时视为队列已满呢？
有这样的疑问是正常的，但是，是否发现，因为我们要把头“指针”front 和 尾“指针”rear 相等时作为队列空的情况，所以，队列满的情况还使用的话，就有冲突了！
在这里插入图片描述

好了，既然我们已经知道了循环队列的底层原理了，我们我们是不是就可以码代码了呢？
不急，还差一点。我们如何才能让队首队尾“指针”在到队列尾部时自动调转回到队列的头部呢？

其实有一个很简单的小算法可以搞定：
循环队列入队,队尾循环后移：LQ->rear = (LQ->rear + 1) % QUEUE_MAX;
循环队列出队,队首循环后移：LQ->front = (LQ->front + 1) % QUEUE_MAX;
为什么都要加1呢？是为了保持队首与队尾在队列满时保持一个元素的间距！
在这里插入图片描述

空的队列：LQ->front == LQ->rear // 队首和队尾都指向同一个区块。
满的队列：(LQ->rear + 1) % QUEUE_MAX == LQ->front // 因为队列满时，他们是空开一个元素的，所以，尾指针后移一位正好等于头指针。这也是为什么要空开一个元素的原因。

我们也还可以把循环队列比作一个大圆盘：
在这里插入图片描述

计算元素个数:
可以分两种情况判断：
如果LQ->rear >= LQ->front：元素的个数为：LQ->rear - LQ->front;
如果LQ->rear < LQ->front：元素的个数为：LQ->rear - LQ->front + QUEUE_MAX;

采用取模的方法可以把两种情况统一为：(LQ->rear - LQ->front + QUEUE_MAX) % QUEUE_MAX;

好了，原理讲完了，相信大家都已经非常的了解循环队列了。其实循环队列也不过如此嘛！下面我们一起来码代码！

定义

我们可以给队列的最大存储定义一个宏：
#define QUEUE_MAX 5 // 循环队列的最大存储个数

#define QUEUE_MAX 5		// 循环队列的最大存储个数

typedef int DateType;	// 循环队列存储的类型

typedef struct ArrayQueue {
	DateType queue[QUEUE_MAX];	// 存储循环队列元素的数组
	int front;	// 对头“指针”
	int rear;	// 队尾“指针”
}LoopQueue;

反正小编觉得就是和第一集中的循序存储队列一毛一样！

初始化循环队列

// 初始化循环队列
bool inItLoopQueue(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	LQ->front = LQ->rear = 0;

	return true;
}

在这里插入图片描述
头尾“指针”都赋值零。
反正小编觉得就是和第一集中的循序存储队列一毛一样！

判断循环队列是否为空

// 判断循环队列是否为空
bool estimateLoopQueueEmpty(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (LQ->front == LQ->rear) {	// 当头尾“指针”相等时，为空队列
		return true;
	}

	return false;
}

在这里插入图片描述
当头尾“指针”相等时，就是空队列！
程序员看图说话，不信的看上图！

判断循环队列是否已满

// 判断循环队列是否已满
bool estimateLoopQueueFull(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if ((LQ->rear + 1) % QUEUE_MAX == LQ->front) {	// 队尾指针与对头指针相差一个元素的间隔时为满
		return true;
	}

	return false;
}

在这里插入图片描述
队尾“指针” 与 队首“指针”空开一个元素的间隔，所以判断条件可以将队尾“指针”加一后于队首“指针”作比较，当他们相等时，说明队列已满！
程序员看图说话，不信的看上图！

入队，将元素插入循环队列中

// 入队，将元素插入循环队列中
bool loopQueueInsert(LoopQueue* LQ, DateType date) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (estimateLoopQueueFull(LQ)) {
		cout << "循环队列已满！" << endl;
		return false;
	}

	LQ->queue[LQ->rear] = date;	// 存值
	LQ->rear = (LQ->rear + 1) % QUEUE_MAX;	// 队尾指针加1
	
	return true;
}

在这里插入图片描述
当队列有元素出队时，前面的位置会空出来，我们的循环队列可以循环重复利用那里的内存，所以我们可以在前面插入！
插入也只是需要将队尾“指针”加一后与队列的最大存储进行与运算，均可得到队尾“指针”的下一个位置。

出队，将元素从队列中删除

// 出队
bool delteLoopQueue(LoopQueue* LQ, DateType* date) {	// 参数二：保存出队的元素返回
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (!date) {
		cout << "date指针为NULL" << endl;
		return false;
	}

	if (estimateLoopQueueEmpty(LQ)) {
		cout << "循环队列为空，出队失败!" << endl;
		return false;
	}

	*date = LQ->queue[LQ->front];	// 获取出队的元素

	LQ->front = (LQ->front + 1) % QUEUE_MAX;	// 头指针加一

	return true;
}

在这里插入图片描述
出队也只是需要将队首“指针”加一后与队列的最大存储进行与运算，均可得到队首“指针”的下一个位置。

获取队首的元素

// 获取队首的元素
bool gainLoopQueueFrontValue(LoopQueue* LQ, DateType* date) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (!date) {
		cout << "date指针为NULL" << endl;
		return false;
	}

	if (estimateLoopQueueEmpty(LQ)) {
		cout << "循环队列为空，获取失败!" << endl;
		return false;
	}

	*date = LQ->queue[LQ->front];	// 获取出队的元素

	return true;
}

简单合法性检查后，将头节点对应下标的元素赋值给date返回即可！

获取循环队列的元素个数

// 获取循环队列的元素个数
int size(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return 0;
	}

	return (LQ->rear - LQ->front + QUEUE_MAX) % QUEUE_MAX;
}

代入原理精讲那条算法式子，就可以计算出当前队列的元素个数了！

输出队列中的元素

// 输出队列中的元素
void queuePrint(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return;
	}

	if (estimateLoopQueueEmpty(LQ)) {
		cout << "循环队列为空!" << endl;
		return;
	}

	int i = LQ->front;

	while (i != LQ->rear) {
		cout << LQ->queue[i] << "\t";
		i = (i + 1) % QUEUE_MAX;
	}
	cout << endl;
}

这里我们需要定义整型变量 i 将头指针赋值给他，循环遍历当 i 不等于尾指针时，执行循环。循环体内输出当前 i 下标的元素后，将i + 1后与队列的最大存储作取余，就可以兼顾下图的情况了！
在这里插入图片描述

清空队列

//清空队列
void clearLoopQueue(LoopQueue* LQ)
{
	if (!LQ) return;
	LQ->front = LQ->rear = 0;
}

和初始化一毛一样，将头“指针”和尾“指针”头赋值0即可!

测试代码：

#include <iostream>
#include <Windows.h>

using namespace std;

#define QUEUE_MAX 5		// 循环队列的最大存储个数

typedef int DateType;	// 循环队列存储的类型

typedef struct ArrayQueue {
	DateType queue[QUEUE_MAX];	// 存储循环队列元素的数组
	int front;	// 对头“指针”
	int rear;	// 队尾“指针”
}LoopQueue;

// 初始化循环队列
bool inItLoopQueue(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	LQ->front = LQ->rear = 0;

	return true;
}

// 判断循环队列是否为空
bool estimateLoopQueueEmpty(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (LQ->front == LQ->rear) {	// 当头尾“指针”相等时，为空队列
		return true;
	}

	return false;
}

// 判断循环队列是否已满
bool estimateLoopQueueFull(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if ((LQ->rear + 1) % QUEUE_MAX == LQ->front) {	// 队尾指针与对头指针相差一个元素的间隔时为满
		return true;
	}

	return false;
}

// 入队，将元素插入循环队列中
bool loopQueueInsert(LoopQueue* LQ, DateType date) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (estimateLoopQueueFull(LQ)) {
		cout << "循环队列已满！" << endl;
		return false;
	}

	LQ->queue[LQ->rear] = date;	// 存值
	LQ->rear = (LQ->rear + 1) % QUEUE_MAX;	// 队尾指针加1
	
	return true;
}

// 出队
bool delteLoopQueue(LoopQueue* LQ, DateType* date) {	// 参数二：保存出队的元素返回
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (!date) {
		cout << "date指针为NULL" << endl;
		return false;
	}

	if (estimateLoopQueueEmpty(LQ)) {
		cout << "循环队列为空，出队失败!" << endl;
		return false;
	}

	*date = LQ->queue[LQ->front];	// 获取出队的元素

	LQ->front = (LQ->front + 1) % QUEUE_MAX;	// 头指针加一

	return true;
}

// 获取队首的元素
bool gainLoopQueueFrontValue(LoopQueue* LQ, DateType* date) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return false;
	}

	if (!date) {
		cout << "date指针为NULL" << endl;
		return false;
	}

	if (estimateLoopQueueEmpty(LQ)) {
		cout << "循环队列为空，获取失败!" << endl;
		return false;
	}

	*date = LQ->queue[LQ->front];	// 获取出队的元素

	return true;
}

// 获取循环队列的元素个数
int size(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return 0;
	}

	return (LQ->rear - LQ->front + QUEUE_MAX) % QUEUE_MAX;
}

// 输出队列中的元素
void queuePrint(LoopQueue* LQ) {
	if (!LQ) {
		cout << "循环队列不存在！" << endl;
		return;
	}

	if (estimateLoopQueueEmpty(LQ)) {
		cout << "循环队列为空!" << endl;
		return;
	}

	int i = LQ->front;

	while (i != LQ->rear) {
		cout << LQ->queue[i] << "\t";
		i = (i + 1) % QUEUE_MAX;
	}
	cout << endl;
}

//清空队列
void clearLoopQueue(LoopQueue* LQ)
{
	if (!LQ) return;
	LQ->front = LQ->rear = 0;
}

int main(void) {
	LoopQueue LQ;
	DateType date = 0;

	// 初始化
	inItLoopQueue(&LQ);

	// 入队
	for (int i = 0; i < 7; i++) {
		loopQueueInsert(&LQ, i);
	}
	cout << "队列中的元素个数：" << size(&LQ) << endl;
	queuePrint(&LQ);

	// 出队
	for (int i = 0; i < 2; i++) {
		if (delteLoopQueue(&LQ, &date)) {
			cout << "出队成功，出队的元素是：" << date << endl;
		}
	}
	cout << "队列中的元素个数：" << size(&LQ) << endl;
	queuePrint(&LQ);

	// 入队
	for (int i = 0; i < 3; i++) {
		loopQueueInsert(&LQ, i*3);
	}
	cout << "队列中的元素个数：" << size(&LQ) << endl;
	queuePrint(&LQ);

	clearLoopQueue(&LQ);

	system("pause");
	return 0;
}

运行截图：
在这里插入图片描述

总结：
其实循环队列就是顺序储存队列的扩展版，基本操作都是一样的，算法难度不是很大！注意好队尾“指针”是如何回到队列的头部位置那些简单算法就行！加油！

注意：由于一篇博客内容太多，所以我将会把他分成几篇进行讲解！

祝各位学习愉快！

下集预告：
你将学会企业级队列的应用：优先链式存储队列；
请持续关注！

cpp_learners
关注
专栏目录
【源代码】C++算法（四）队列的基本操作 （用队列实现十进制转换十六进制）
03-30
【源代码】C++算法（四）队列的基本操作 （用队列实现十进制转换十六进制）
C++ 循环队列基本算法实现
weixin_34013044的博客
11-24 415
C++ 循环队列基本算法实现 #ifndef CircleQueue_h #define CircleQueue_h const int QueueSize = 1000; template <class T> class CircleQueue { public: CircleQueue(){front = rear = 0;} void E...
C++一本通基础算法：队列
zxh_minecraft的博客
07-20 268
队列
关于 C++ 队列算法，你该了解这些【第一集：顺序存储队列】
cpp_learner的博客
04-02 715
观看本篇博文提醒： 你将学会队列的两种最基本的表现形式：顺序存储队列 和 链式存储队列； 一个扩展队列的使用方法：循环队列； 两个企业级队列的应用：线性池中的任务队列 和 优先链式存储队列。 队列的原理 队列是一种受限的线性表，(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out). 例如上图中，圆球1先进，也是圆球1先出。 队列是一种受限的线性结...
队列用c++实现
HHHHHHep的博客
11-29 524
由于经常用到队列，因此将队列的实现， 代码入下typedef struct Node { int data; struct Node *next; }Node; typedef struct Queue { Node *head, *tail; }Queue; void Initi(Queue &Q) { Q.head = (Node *)malloc(sizeof
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队
06-04
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队 适合大二初学数据结构与算法 程序有详细备注，可直接运行 顺序表
C++数据结构与算法之双缓存队列实现方法详解
08-29
C++数据结构与算法之双缓存队列实现方法详解 本文主要介绍了C++数据结构与算法之双缓存队列实现方法，结合实例形式分析了双缓存队列的原理、实现方法与相关注意事项。 知识点一：双缓存队列的定义 双缓存队列是一...
循环队列 C++不同策略模板实现
12-11
4. **C++实现循环队列**：C++中，我们可以使用`std::array`或动态分配的数组来表示队列的存储空间，用两个指针分别表示队头和队尾的位置。为了实现循环，我们需要在进行进队和出队操作时处理边界条件，例如队头等于...
基于C++实现SJF短优先算法+HRRN高响应比优先调度算法+多级反馈队列调度算法源码.zip
08-18
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业...基于C++实现SJF短优先算法+HRRN高响应比优先调度算法+多级反馈队列调度算法源码.zip
C++数据结构之实现循环顺序队列
12-31
数据结构–用C++实现循环顺序队列 队列的操作特性：先进先出 队列中元素具有相同类型 相邻元素具有前驱和后继关系 设置队头、队尾两个指针，以改进出队的时间性能 约定：队头指针front指向队头元素的前一个位置...
C++实现循环队列
08-25
主要为大家详细介绍了C++实现循环队列，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
循环队列的实现和运算.cpp
04-04
循环队列的实现和运算.cpp
04-栈的操作、循环队列的操作.cpp
12-11
04-栈的操作、循环队列的操作.cpp
数据结构C/C++队列算法
li99yangg的博客
10-08 706
假设以带头结点的循环链表来表示队列，并且只设一个指针指向队尾，编写相应的置队空、入队、出队算法。并且还要设计直观的用户操作界面，能直观看到操作结果。 #include #include #include #include #include #include using namespace std; typedef int Datatype; typedef s
数据结构与算法C++（九）队列
yang_jianfeng的博客
08-18 161
队列 队列和栈一样，是一种特殊的线性表。队列的插入和删除操作分别在线性表的两端进行，因此，队列是一个先进先出（FIFO）的线性表。 插入元素的那一端称为队尾（back或rear），删除元素的那一端称为队首（front）。 ...
数据结构与算法（C++）– 队列（Queue）
Wang_Jiankun的博客
09-01 909
数据结构与算法（C++）– 队列（Quene） 1、队列
走进数据结构和算法（c++版）（5）——队列
_微尘_的博客
06-02 934
队列
【数据结构】C++语言实现队列(详细解读)
最新发布
bhbcdxb123的博客
05-09 1944
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（head）进行删除操作，而在表的后端（tail）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。这个队列就可以理解成我们平时的排队，先进入的先出去，与我们之前实现的先进后出的栈相反。typedef struct QueueNode//队列的元素节点}QNode;typedef struct Queue//队列int size;}Queue;
优先队列与二叉堆解析：数据结构与算法C++第四版
"数据结构与算法分析C++第四版课件_优先队列" 优先队列是一种特殊类型的队列，它遵循“优先级高的元素优先出队”的原则，常用于处理紧急事件或者高优先级的任务。在传统的队列中，遵循先进先出（FIFO）的规则，但在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cpp_learners

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值