带你一步步用C++实现循环队列

最新推荐文章于 2024-05-22 17:17:45 发布
最新推荐文章于 2024-05-22 17:17:45 发布
阅读量3.5k 收藏 38
点赞数 4
分类专栏： 数据结构 文章标签： c++ 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43744293/article/details/116788056
版权

C++实现循环队列

前言

有关队列的介绍，如队列的常用操作，循环队列和链式队列的优缺点对比等，可参考队列简介及常用操作

创建一个Queue类，确定成员函数和数据成员

template <typename T>
class Queue
{
	Queue(int _capacity = 10);
	~Queue();

	void Push(const T& _data);//入队
	void Pop();//出队，既删除
	T& Front();//返回队首数据
	T& Rear();//返回队尾数据
	bool Empty();//判断队列是否为空
	int size();//返回队列的大小

private:
	T* queue;//顺序队列的存储数组
	int front;//队首标号
	int rear;//队尾标号
	int capacity;//队列的容量
};

1.什么时候循环队列为空

如果front 和rear都指向有数据的标号位置：

  1. 在队列初始化时，front和rear都为0，此时队列是为空的,front = rear。
  2. 当队列中只有一个数据时，front和rear都指向同一个位置，此时front=rear。
  3. 当队列有两个以上数据时，front≠rear；

通过以上情况讨论，可以发现：如果front和rear都指向有数据的标号位置，当front=rear时，我们判断不了队列是空还是有一个数据。为此，我们可以空出一个元素，既让front指向队首的前一个元素（front空）或者让rear指向队尾的后一个元素（rear空），示意图如下。这样我们就可以用front=rear作为队列空的判断条件，仅仅影响的是队列的容量，比实际大小减1。

在这里插入图片描述
不难写出成员函数Empty()：

template <typename T>
bool Queue<T>::Empty()
{
	if (front == rear)
		return true;
	else
		return false;
}

注意：后面的叙述，我都以“让front指向队首的前一个元素（front空）”为例来编写代码。

2.Push()操作

要处理两个问题：

  • 何时队列满了?
  • 当队列满了，怎样扩大队列？

(1)何时队列满了?

队列满的情况如下图所示：
在这里插入图片描述
当然，我们可以写出如下代码：

if (	(rear > front && (rear - front + 1) == capacity) ||
	(rear < front && rear + 1 == front)			)
{
	//队列满了
}

但是，我们有更简洁的方法，因为rear和front都是以队列大小(capacity)为一个环状进行改变，所以可以想到对capacity取余的方法。代码如下：

if ( (rear +1) % capacity == front )
{
	//队列满了
}

综上，我们就有了队列满的判断条件：(rear +1) % capacity == front

(2)当队列满了，怎样扩大队列？

方法很简单，申请新的内存，大小是原来的两倍。不过这里需要分情况讨论，分别针对的是队列满的两种情况。对于第一种情况，直接把从front到rear的数据复制到新的内存空间；对于第二种情况，需要分两段，第一段为front到队列下标capacity-1，另一段为队列下标0到rear。示意图如下：
第一种情况：
在这里插入图片描述
第二种情况：
在这里插入图片描述

现在可以写自动扩大队列的代码了：

		T * newQueue = new T[capacity * 2];//申请大的内存空间

		if (front < rear){
			//对应队列满的情况1
			std::copy(queue + front + 1, queue + rear + 1, newQueue);
		}
		else{
			//对应队列满的情况2
			T* rtnaddr = std::copy(queue + front + 1, queue + capacity, newQueue);
			std::copy(queue, queue + rear + 1, rtnaddr);
		}

		//重新确定rear和front的位置
		rear = capacity - 2;//不扩大之前的队列的元素个数为capacity-1
		capacity *= 2;//大小扩大一倍
		front = capacity - 1;//front指向数组的最后一个下标

		delete[] queue;//释放原来的内存
		queue = newQueue;

注意：由于C++编译器是不检查数组越界的，所以，即使程序员不自己扩容，使用越界的索引程序也不会报错，只是它会继续向下占用一块内存。程序员必须注意数组越界的问题。

扩容时使用了algorithm中的copy函数，有关std::copy()函数的介绍，可参考：C++ STL:algorithm 中的std::copy std::copy_backward函数

注意：使用std::copy时会报错，解决方法是：在预处理器加入(项目属性—>C/C++—>预处理—>预处理器定义)：_SCL_SECURE_NO_WARNINGS。

完整的push()代码如下：

template <typename T>
void Queue<T>::Push(const T& _data)
{
	//判断队列是否满了，满了就扩大队列
	if ( (rear +1) % capacity == front ){
		T * newQueue = new T[capacity * 2];//申请大的内存空间

		if (front < rear){
			//对应队列满的情况1
			std::copy(queue + front + 1, queue + rear + 1, newQueue);
		}
		else{
			//对应队列满的情况2
			T* rtnaddr = std::copy(queue + front + 1, queue + capacity, newQueue);
			std::copy(queue, queue + rear + 1, rtnaddr);
		}

		//重新确定rear和front的位置
		rear = capacity - 2;//不扩大之前的队列的元素个数为capacity-1
		capacity *= 2;//大小扩大一倍
		front = capacity - 1;//front指向数组的最后一个下标

		delete[] queue;//释放原来的内存
		queue = newQueue;
	}

	rear = (rear + 1) % capacity;
	queue[rear] = _data;
}

(3)std::copy()的用法

在扩大队列的过程中，我们使用了STL algorithm中的copy()函数，有关它的用法，我已近在C++ STL:algorithm 中的std::copy std::copy_backward函数中详细介绍了，感兴趣的小伙伴可以看看。

3.队列中现有多少个元素怎么算

不用想，肯定为front和rear的差值，但是需要考虑到回环的情况。若是rear>front，大小为rear-front；若是rear<front，肯定是rear回环了，所以先补回回环的大小，在减去front，即大小为rear + capacity – front。综合一下两种情况，用一个表达式表示：(rear + capacity – front)% capacity。举例，假设capacity = 6，若front = 1，rear = 4,此时大小为(4+6- 1)%6 = 3；若front = 4，rear = 1，此时大小为(1+6-4)%6 = 3。

所以，我们写出Size()的内容如下：

template <typename T>
int Queue<T>::Size()
{
	return (rear + capacity - front) % capacity;
}

4.其他成员函数

至于剩下的Pop()、Front()和Rear()，只需找到队首和队尾的位置即可。队尾的数据很简单，就是queue[rear]；front指向的位置由于是空的，所以队首的数据需要用回环操作，即queue[(front+1)%capacity]。

5.实例代码及运行结果：

Queue.h

#ifndef _QUEUE_H
#define _QUEUE_H

template <typename T>
class Queue
{
public:
	Queue(int _capacity = 10);
	~Queue();

	void Push(const T& _data);//入队
	void Pop();//出队，既删除
	T& Front();//返回队首数据
	T& Rear();//返回队尾数据
	bool Empty();//判断队列是否为空
	int Size();//返回队列的大小

private:
	T* queue;//顺序队列的存储数组
	int front;//队首标号
	int rear;//队尾标号
	int capacity;//队列的容量
};

//构造函数和析构函数
template <typename T>
Queue<T>::Queue(int _capacity)
:capacity(_capacity), queue(nullptr), front(0), rear(0)
{
	if (capacity < 1)
		exit(1);
	else
		queue = new T[capacity];
}
template <typename T>
Queue<T>::~Queue()
{
	delete[] queue;
}

//push
template <typename T>
void Queue<T>::Push(const T& _data)
{
	//判断队列是否满了，满了就扩大队列
	if ( (rear +1) % capacity == front ){
		T * newQueue = new T[capacity * 2];//申请大的内存空间

		if (front < rear){
			//对应队列满的情况1
			std::copy(queue + front + 1, queue + rear + 1, newQueue);
		}
		else{
			//对应队列满的情况2
			T* rtnaddr = std::copy(queue + front + 1, queue + capacity, newQueue);
			std::copy(queue, queue + rear + 1, rtnaddr);
		}

		//重新确定rear和front的位置
		rear = capacity - 2;//不扩大之前的队列的元素个数为capacity-1
		capacity *= 2;//大小扩大一倍
		front = capacity - 1;//front指向数组的最后一个下标

		delete[] queue;//释放原来的内存
		queue = newQueue;
	}

	rear = (rear + 1) % capacity;
	queue[rear] = _data;
}
template <typename T>
void Queue<T>::Pop()
{
	if (!Empty())
		front = (front + 1) % capacity;
	else
		exit(1);
}

template <typename T>
T& Queue<T>::Front()
{
	if (!Empty())
		return queue[(front + 1) % capacity];
	else
		exit(1);
}
template <typename T>
T& Queue<T>::Rear()
{
	if (!Empty())
		return queue[rear];
	else
		exit(1);
}

//判断队列是否为空
template <typename T>
bool Queue<T>::Empty()
{
	if (front == rear)
		return true;
	else
		return false;
}
//返回队列的大小
template <typename T>
int Queue<T>::Size()
{
	return (rear + capacity - front) % capacity;
}

#endif

main.cpp

#include <iostream>
#include "Queue.h"

using namespace std;

int main()
{
	cout << "测试队列的正确性:"<<endl;
	Queue<int> q(5);

	for (int i = 0; i < 5; i++){
		q.Push(i);
	}

	while (!q.Empty())
	{
		cout << "size = " << q.Size() << "\t";
		cout << "front = " << q.Front()<< endl;
		q.Pop();
	}

	cout << "\n测试队列的自动扩大功能:" << endl;
	for (int i = 0; i < 5; i++){
		q.Push(i);
	}
	q.Push(5);//队列大小为5，现在加入第6个数据

	while (!q.Empty())
	{
		cout << "size = " << q.Size() << "\t";
		cout << "front = " << q.Front() << endl;
		q.Pop();
	}

	system("pause");
	return 0;
}

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

思考：

当我们把队列的初始大小定义为1时，push数据时发生了什么？
可以发现，此时必定满足队列满的条件：(rear +1) % capacity == front。所以我们是先把队列的大小扩大为2后，再把数据push进队列中。

总结

  • 判空条件：front == rear
  • 判满条件：(rear + 1) % capacity == front
  • 队列中元素个数：(rear + capacity – front)%capacity
  • 队首元素下标：(front + 1)%capacity
  • 队尾元素下标：rear

到这里，我们就实现了C++版的循环队列，本人水平有限，欢迎各位码友批评指正。

相关文章：
（1）链式队列：数据结构——链式队列(C++)
（2）队列的介绍：队列简介及常用操作
（3）copy()的用法：C++ STL:algorithm 中的std::copy std::copy_backward函数

代码乌龟
关注
  • 4
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——链式队列(C++)
weixin_43744293的博客
05-17 1757
链式队列1.定义队列类2.队列类Queue的构造函数和析构函数3.Push()函数4.Pop()函数5.Empty()函数6.Size()函数7.Front()和Rear()函数完整代码及测试 队列的简介，可参考：队列简介及常用操作 1.定义队列类 由于使用的是式结构，所以在队列类中定义了一个队列节点结构。定义了队首和队尾两个数据成员。 template <typename T> class Queue { public: Queue(); ~Queue(); void Push(con
<4>数据结构与算法（C/C++实现）视频教程
06-10
课程全程讲师手敲代码，一步步代你走进数据结构与算法。本课程涉及的数据结构与算法有，栈，队列，单向链表，双向循环链表，树，二叉树，搜索二叉树，平衡搜索二叉树，冒泡，选择，直插，希尔，，归并等，课程还涉及...
C++实现循环队列（数组模拟）【保姆级讲解】
weixin_55755506的博客
12-10 3599
看起来还不错，但仔细观察出队到队空时，队列里面没有数了，也就是队空了，可以继续加数据，但是，表示队列头尾的变量已经到了数组的最右边的下一个索引，已经没办法再往右了，同时数组还是空的。这里可以将数组的一个格子空出来，当数组还有一个格子的时候，就当作队列已经满了。出队的话，可以利用和入队类似的办法，但数组无法删除元素，但我们可以用一个数组索引的变量表示队头的位置，每次出队只需把这个索引向递增即可。这样看起来可以，但是有一个问题，我们需要时刻记得我们入队了几次，否则就无法根据索引入队了。没有到达数组末尾的时候，
C++实现各种队列（详解）——普通队列，双端队列，优先队列
最新发布
qq_44182424的博客
05-22 268
【代码】C++实现各种队列（详解）——普通队列，双端队列，优先队列。
队列概念|循环队列的实现
wangjiushun的博客
10-29 231
本文讲解了队列的概念和循环队列，并用C语言实现了循环队列
数据结构之堆——C++实现大顶堆和小顶堆
weixin_43744293的博客
07-07 5654
大小顶堆的实现什么是大顶堆和小顶堆大小顶堆的底层实现代码实现小顶堆定义小顶堆类构造函数插入扩大堆数组容量删除析构函数代码实现大顶堆测试 什么是大顶堆和小顶堆 堆是一种完全二叉树。完全二叉树的定义：所有节点从上往下，从左往右的依次排列，不能有空位置，是为完全二叉树。下面是完全二叉树和不完全二叉树的示意图： 大顶堆定义：父节点都大于左右子节点。 小顶堆定于：父节点都小于左右子节点。 二者示意图如下： 大小顶堆的底层实现 一般来说，定义二叉树都是定义一个节点类，节点类中包含本节点的数据元素和两个节点指针，分别
Win32 消息队列循环机制【转载】
weixin_44820850的博客
06-18 685
Dos的过程驱动与Windows的事件驱动 在讲本程序的消息循环之前，我想先谈一下Dos与Windows驱动机制的区别: DOS程序主要使用顺序的，过程驱动的程序设计方法。顺序的，过程驱动的程序有一个明显的开始，明显的过程及一个明显的结束，因此程序能直接控制程序事件或过程的顺序。...
C++实现高并发Web服务器
weixin_51768320的博客
11-20 3280
1.服务器编程基本框架 服务器程序种类繁多，但其基本框架都是一样的，它们的不同之处在于逻辑处理。如图所示是服务器的基本框架。 该图既能用来描述一台服务器，也能用来描述一个服务器机群。如下是各个部件的含义和功能。 模块 单个服务器程序 服务器机群 IO处理单元 处理客户连接，读写网络数据 作为接入服务器，实现负载均衡 逻辑单元 业务进程
用一个示例讲解我如何一步步实现高并发服务（基于C++）
热门推荐
lucasma的博客
03-29 1万+
去年做了一个远程升级的服务。客户端连接此服务可以下载更新程序。简单点说就是个TCP sever。基于C++。运行环境是centOS 6.5。刚开始客户端数量少而且访问不频繁，所以没太关注并发的问题。当时用工具测试大概只能支持的40次/秒的并发访问，而且已经有数据串包的情况出现了。最近有空做了不少的优化并记录了笔记备忘。下面给出的代码都不是完整的项目源码，我只是截取了关键部分用于说明主题我选择的测试工
队列应用---C++＜queue＞
naexting的博客
01-27 332
这几天学了c++的std，里面有几个容器适配器挺好用的，今天就介绍一个队列。 (std::queue)是一种**先进先出（Fist In，First Out）**的容器适配器，仅支持查询或删除第一个 加入的元素（队首元素），不支持随机访问，且为了保证数据的严格有序性，不支持迭代器。 队列的定义： (以int 类型为例） queue<int> q;//定义了一个存储int 类型的队列 //或 queue<int> q2(q1);//以q1为模板定义一个队列q2 成员函数： q.fro
C++ 入门导引（这是一篇由GPT4写的文章）
巫山老妖
05-28 1045
C++ 由 Bjarne Stroustrup 在 1980 年代初创立，最初被称为 “C with Classes”。C++ 设计的目的是为了弥补 C 语言在支持抽象结构、代码复用和组织方面的不足。随着时间的推移，C++ 得到了持续的发展，添加了更多高级特性，并形成了目前功能强大的编程语言。
C++ 简单练习上手小项目
12-19
在C++编程语言的学习过程中，实践是至关重要的。"C++简单练习上手小项目"是一个专门为初学者设计的资源，旨在帮助他们通过实际...在实践中不断挑战自己，从简单的代码片段到完整的程序，一步步成长为熟练的C++程序员。
C++ 写的一个窗口
10-19
在描述中提到，这个示例对于初学者很有帮助，这意味着它可能包含了一些基础的示例代码，展示了如何一步步实现上述过程。在学习过程中，理解每个函数的作用、参数和返回值是非常重要的，同时，熟悉Windows消息系统是...
cPPlearnning.rar_Windows编程_C++_
08-11
总的来说，这个“cPPlearnning”教程将带你走过C++编程和Windows应用开发的旅程，从基础到进阶，一步步打造你的编程技能。记住，实践是最好的老师，理论知识结合实际项目练习，将使你更快地成为熟练的C++程序员和...
C++编程的实例
09-12
这种结构化的学习资源对于逐步进阶非常有帮助，因为它鼓励你一步步地挑战自己，从简单的练习开始，逐渐过渡到更复杂的任务。 学习这些实例时，你应该先阅读并理解代码的逻辑，然后尝试运行并分析结果。如果遇到错误...
递归法求二叉树的深度
weixin_43744293的博客
05-18 8732
想要计算一个二叉树的深度，我们先可以拆成求根结点的左右子树的深度；而根结点的左右子树的深度又可拆成求根左结点的左右子树深度和根右结点的左右子树的深度。这样一层一层给套下去，很容易想到递归。 明确每一步重复的任务: 计算节点左右子树的深度，并取其最大值。 确认递归的形参和返回值： 形参肯定为某节点的地址，不然算谁的子树高度呢！ 返回值当然为当前子树的最大深度。这里注意，我们算出了节点的左右子树深度的最大值时，还需加1作为返回值，因为节点本身也是一层。 确认递归结束条件： 当节点为空时，递归结束。
C语言实现二叉树的非递归中序遍历
weixin_43744293的博客
05-16 4258
C语言实现二叉树的非递归中序遍历创建一个栈栈的操作函数怎样实现非递归中序遍历完整代码和测试结果 创建一个栈 注意，这个栈的目的时用来保存结点地址的。因为我们在出栈时，还需判断结点的右节点的情况，如果只是保存结点的值，是无法实现中序遍历的。 现在我们来创建一个栈。首先定义一个栈的结构，不过之前还需定义一个节点结构 节点定义 typedef struct BinaryTreeNode{ int data; struct BinaryTreeNode *lchild, *rchild;//左右孩子指针 }B
数据结构——详解二叉查找树(BST)的删除操作
weixin_43744293的博客
07-06 3749
注意：此篇文章只是详细介绍文章数据结构——实现一个二叉查找树（BST）实现的二叉树的删除操作，所以一些类的定义并不在本文中。 **删除节点分类**： 删除的结点是叶子节点 需要做两件事： 断开和父节点的连接 释放删除节点的内存 由于这种情况很简单，不做说明，可参见代码。 删除的结点不是叶子节点 此时删除的节点必定有左子树或右子树或者两者兼具。 以图1的二叉树为例，我们可以有两种做法。就以删除节点3为例，即可以将节点3左子树的最大值节点补在节点3的位置，也可以将节点3右子树的最小值节点补在
用c++实现循环队列
11-06
循环队列是一种解决队列空间浪费和越界问题的方法，它可以通过牺牲一个存储空间来实现队列满的判断。下面是用C++实现循环队列的代码： ``` const int MAX_SIZE = 4; // 队列的容量 class CircularQueue { private: int front; // 队头指针 int rear; // 队尾指针 int data[MAX_SIZE]; // 存储队列元素的数组 public: CircularQueue() { front = rear = 0; // 初始化队头和队尾指针 } bool isEmpty() { return front == rear; // 判断队列是否为空 } bool isFull() { return (rear + 1) % MAX_SIZE == front; // 判断队列是否已满 } bool enqueue(int x) { if (isFull()) { return false; // 队列已满，插入失败 } data[rear] = x; // 插入元素到队尾 rear = (rear + 1) % MAX_SIZE; // 队尾指针后移 return true; // 插入成功 } bool dequeue() { if (isEmpty()) { return false; // 队列为空，删除失败 } front = (front + 1) % MAX_SIZE; // 队头指针后移 return true; // 删除成功 } int getFront() { if (isEmpty()) { return -1; // 队列为空，返回-1 } return data[front]; // 返回队头元素 } }; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值