数据结构之——单向循环队列完备版（C++实现）

最新推荐文章于 2024-07-23 15:47:42 发布
最新推荐文章于 2024-07-23 15:47:42 发布
阅读量875 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： c++ 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GaoXiaoYuan0728/article/details/107822799
版权

单向循环队列

⚪简介

我看了网上C++实现的队列大都是用之前所学的链表来实现，因为不用考虑内存溢出问题，其实单向的队列主要功能是队尾入队和队头出队，是在头和尾实现，若是没有循环在队头这一块的处理动态数组的复杂度为O(n)，而链表是O(1)，当然选用链表来实现。但是当将动态数组优化使其循环，可做到几乎所有功能的平均复杂度都可以做到O(1)。
单向循环队列
队头(front)：用来存储队头元素的下标
若是要出队则将队头元素往下加1
出队
若是要出队则往队尾添加元素
添加元素前
而循环队列的特别点在于当添加元素已放到最后一个位置时，此时是一种假溢出的情况，即整个数组并非是满的，但是在非循环队列需要动态扩容再开辟一个空间储存，而对于循环队列来说只需要把新添加的元素放到最前端。
添加元素后
则此时队头元素的下标为2，队尾元素的下标为0。
真正满
而当整个数组真的满的时候，即真正快要溢出时再进行动态扩容

其实单向循环队列比较好的地方主要是可以最大化的使用动态数组的空间，不必像之前的动态数组一样删除头部元素后方所有元素都要跟着移动，只需要将头节点指向下一个节点就好，在队尾入队使用也比较巧妙，不是再像之前的单纯的一直在后方加入元素，而是在后方位置不足时候查看数组最前端是否还有空余位置，若是有就放入前方，在不足的情况下再进行动态扩容。

⚪接口设计

#pragma once
#include <iostream>
using namespace std;
template <class E>
class Circle_Single_Queue
{
private:
	int size;
	int front;
	E *elements;

	int ELEMENT_LENGTH = 10;

	int sum_capacity;		//保存此时所有的容量
	void Ensure_Capacity(int capacity);		//动态扩容
	int find_index(int index);		//寻找队列中index位置对应在动态数组的位置
public:
	Circle_Single_Queue()		//默认构造函数
	{
		size = 0;
		front = 0;
		elements = new E[ELEMENT_LENGTH];		//默认长度为10
		sum_capacity = ELEMENT_LENGTH;
	}
	int cau_size();		//求数据队列长度
	bool isEmpty();		//检测是否为空
	void enQueue(E element);		//入队
	E deQueue();		//出队
	E look_front();		//观测队头元素

	void print();
	~Circle_Single_Queue() {};
};

⚪难点讲解

入队

入队特殊情况1
在之前的动态数组进行尾部添加元素时所用的代码时element[size++] = element;但是对于循环队列来说，当队头不在下标0处此句代码就无法实现我们所需要的功能。以上出图片为例，此时的size=3， 执行此句子代码，添加的元素就放入下标为3处，覆盖了原来的元素44。而其实我们真正添加元素下标应该是5即front+size 。
入队特殊情况2.1
而对于此种情况，利用上方的front+size=7超过了所给数组最大下标值，若是此时动态扩容无法达到我们设计循环链表的目的。我们真正想要添加元素的下标应当时0，因此我们要对其取余，即使用(front + size)% Max_Size。
特殊情况2.2
利用上图的情况来检测。front=2，size=6，Max_Size=7,(front+size)%Max_Size=1，正好就是我们所需的下标位置。
因此入队的总代码为：

template <class E>		
void Circle_Single_Queue<E>::enQueue(E element)		//入队
{
	Ensure_Capacity(size + 1);
	elements[(front+size)%Max_Size] = element;		//队头+个数再对长度取余（若是数组队尾已满，可向数组头部添加元素）
	size++;
}

出队

出队出队
对于队列是只能从头部出队，就像日常生活中的排队一样，只有最先到的人才能最先出去。
想要出队我们先要获得队头元素的下标 E Front_Element = elements[front];然后再将原队头元素置空elements[front]=NULL;，接下来把队头往下移一格front++;后size--;，最后再返回出队的元素的值return Front_Elements;
出队特殊情况1
当为上图情况时，我们将队头元素出队，当执行到front++语句时就会报错，因此此时虽然队列中还存在元素，但是front++后front值为7，超过了数组下标的最大值，而我们想要的front的值应该变为下标0。所以我们在此处对front的值再进行取余变成front = (front + 1)%Max_Size;
因此出队的总代码为：

template <class E>
E Circle_Single_Queue<E>::deQueue()		//出队
{
	E front_element = elements[front];		
	elements[front] = NULL;
	front = (front + 1)%Max_Size;		//若队头已移至数组尾部，对其取余，到数组头部
	size--;		
	return front_element;
}

动态扩容

动态扩容
当队列成为真正意义上的满时，我们要对其进行动态扩容。
动态扩容
那么此时我们要把原先的元素从队头到队尾依此放入新的大数组中，再将front重新置零。
此处的动态扩容与动态数组的动态扩容用的是一个原理，因此此处我们可以直接引用动态数组的代码再进行删改。

template <class E>
void ArrayList<E>::EnsureCapacity(int capacity)		//检查是否需要扩容
{
	int oldCapacity = size;
	if (oldCapacity >= capacity)
	{
		return;
	}

	int newCapacity = oldCapacity + (oldCapacity >> 1);		//此处为扩容1.5倍，因为2倍如果有动态缩容功能的话会产生复杂度震荡，经过大数据计算，1.5倍为利用率最高的倍数
	int* NewElements = new int[newCapacity];
	for (int i = 0; i < size; i++)
	{
		NewElements[i] = elements[i];
	}
	elements = NewElements;
}

但是对于循环队列来说，在for循环中不像动态数组的元素是按照下标的值依此排列直接一一赋值即可，而是需要将其改为newelements[i] = elements[(i + front) % Max_Size];把其真正的索引的值放入新的大数组中，最后再将front=0。
动态扩容总代码：

template <class E>
void Circle_Single_Queue<E>::Ensure_Capacity(int capacity)
{
	int Old_capacity = sum_capacity;
	if (Old_capacity >= capacity)
	{
		return;
	}
	int New_capacity = (Old_capacity + (Old_capacity >> 1));
	sum_capacity = New_capacity;
	E* newelements = new E[New_capacity];
	for (int i = 0; i < size; i++)
	{
		newelements[i] = elements[(i + front) % Max_Size];
	}
	elements = newelements;

	front = 0;//重置front

索引映射封装

纵观上部的代码我们可以观察到我们在处理循环队列时，我们经常要对索引进行处理，通常我们要通过(front+size)%Max_Size来获得真正的索引对应的下标值，而其实若不是因为循环，我们直接放入本身的下标值其实逻辑上是对的，因此我们对索引映射到真正的索引对应的下标值进行一个函数封装，在用到索引时直接使用find_index(int index)函数来获得真正索引对应的下标，即newelements[i] = elements[(i + front) % Max_Size];直接改为newelements[i] = elements[find_index(i)];，增加代码的可读性。
封装函数的代码：

int Circle_Single_Queue<E>::find_index(int index)		//寻找队列中index位置对应在动态数组的位置
{
	return (front + index) % sum_capacity;
}

⚪总代码

Circle_Single_Queue.h

#pragma once
#include <iostream>
using namespace std;
template <class E>
class Circle_Single_Queue
{
private:
	int size;
	int front;
	E *elements;

	int ELEMENT_LENGTH = 10;

	int sum_capacity;		//保存此时所有的容量
	void Ensure_Capacity(int capacity);		//动态扩容
	int find_index(int index);		//寻找队列中index位置对应在动态数组的位置
public:
	Circle_Single_Queue()		//默认构造函数
	{
		size = 0;
		front = 0;
		elements = new E[ELEMENT_LENGTH];		//默认长度为10
		sum_capacity = ELEMENT_LENGTH;
	}
	int cau_size();		//求数据队列长度
	bool isEmpty();		//检测是否为空
	void enQueue(E element);		//入队
	E deQueue();		//出队
	E look_front();		//观测队头元素

	void print();
	~Circle_Single_Queue() {};
};

Circle_Single_Queue.cpp

#include "Circle_Single_Queue.h"
template <class E>
int Circle_Single_Queue<E>::cau_size()		//求循环队列长度
{
	return size;
}

template <class E>
bool Circle_Single_Queue<E>::isEmpty()		//判断队列是否为空
{
	return size == 0;
}

template <class E>		
void Circle_Single_Queue<E>::enQueue(E element)		//入队
{
	Ensure_Capacity(size + 1);
	elements[find_index(size)] = element;		//队头+个数再对长度取余（若是数组队尾已满，可向数组头部添加元素）
	size++;
}

template <class E>
E Circle_Single_Queue<E>::deQueue()		//出队
{
	E front_element = elements[front];		
	elements[front] = NULL;
	front = find_index(1);		//若队头已移至数组尾部，对其取余，到数组头部
	size--;		
	return front_element;
}

template <class E>
E Circle_Single_Queue<E>::look_front()
{
	return elements[front];
}

template <class E>
void Circle_Single_Queue<E>::print()
{
	int n = size;
	for (int i = 0; i < n; i++)
	{
		cout << elements[find_index(i)] << "  ";
	}
}

template <class E>
void Circle_Single_Queue<E>::Ensure_Capacity(int capacity)
{
	int Old_capacity = sum_capacity;
	if (Old_capacity >= capacity)
	{
		return;
	}
	int New_capacity = (Old_capacity + (Old_capacity >> 1));
	sum_capacity = New_capacity;
	E* newelements = new E[New_capacity];
	for (int i = 0; i < size; i++)
	{
		newelements[i] = elements[find_index(i)];
	}
	elements = newelements;

	front = 0;//重置front
}

template <class E>
int Circle_Single_Queue<E>::find_index(int index)		//寻找队列中index位置对应在动态数组的位置
{
	return (front + index) % sum_capacity;
}

mian.cpp

#include <iostream>
#include "Circle_Single_Queue.h"
#include "Circle_Single_Queue.cpp"

int main()
{
	Circle_Single_Queue<int> csque;
	csque.enQueue(10);
	csque.enQueue(20);
	csque.enQueue(30);
	csque.enQueue(40);
	csque.enQueue(50);
	csque.enQueue(60);
	csque.print();
	csque.enQueue(70);
	csque.enQueue(10);
	csque.enQueue(20);
	csque.enQueue(30);
	csque.enQueue(40);
	csque.enQueue(50);
	csque.enQueue(60);
	csque.enQueue(70);
	csque.print();
	return 0;
}

代码都经过测试检测，可放心食用~

GXM.
关注
专栏目录
C++使用linked list(链表)实现circular queue(循环队列)(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-10 608
使用linked lis实现circular queuenode结构体定义使用linked list(链表)实现circular queue(循环队列)算法的完整源码（定义，实现，main函数测试） node结构体定义 struct node { int data; struct node *next; }; 使用linked list(链表)实现circular queue(循环队列)算法的完整源码（定义，实现，main函数测试） #include <iostream> st
C++模板实现的单向队列
eskimoer的专栏
02-27 1678
C++模板实现的单向队列的元素添加，元素删除，元素清除功能 //Queues.h #ifndef DDXX_QUEUES_H #define DDXX_QUEUES_H #include using namespace std; template class Queues { public: Queues(); ~Queues(); public: struct Node {
C/C++数据结构（五） —— 单向队列
热门推荐
Edison's 小宇宙
10-04 1万+
队列（queue） 是⼀种线性数据结构，队列中的元素只能 先⼊先出。
单向队列（循环队列）
执妄
11-30 335
package queue; /** * 实现自己的队列 */ public class QueueTest1 { public static void main(String[] args) { MyQueue myQueue = new MyQueue(3); myQueue.insert(1); myQueue.insert(2); myQueue.insert(3); System.out.println
数据结构之——双向循环队列完备版（C++实现）
GaoXiaoYuan0728的博客
08-09 813
循环双端队列实际上就是是在之前单向的循环队列的基础上可以进行两端添加、删除操作的循环队列，因此我们在函数中增加了头部入队和尾部删除。 而对于队尾元素没必要再设置一个变量，因为尾部的变量直接可以用front+size 下面是 Circle_Double_Queue.h的代码。 #pragma once #include <iostream> using namespace std; template <class E> class Circle_Double_Queue { pri
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
数据结构C++——队列
最新发布
qq_60987997的博客
07-23 705
队列（queue）是一个线性表，其插入和删除操作分别在表的不同端进行。添加新元素的那一端被称为队尾删除元素的那一端被成为队首队列是一个先进先出（ first-in-first-out, FIFO）的线性表。
图解数据结构C++版源码
01-13
《图解数据结构》是一本深受程序员喜爱的书籍，它以直观易懂的方式介绍了各种重要的数据结构及其在C++中的实现。源码是学习和理解数据结构的关键辅助工具，能够帮助读者更深入地掌握每种数据结构的工作原理。在这个...
数据结构（从概念到C++实现）
m0_54285007的博客
09-05 6761
目录 第2章 线性表 2.1 引言 2.2 线性表的逻辑结构 2.2.1 线性表的定义 2.2.2 线性表的抽象数据类型定义 第2章 线性表 2.1 引言 线性表是描述单一的前驱和后继的关系 2.2 线性表的逻辑结构 2.2.1 线性表的定义 线性表是一个有限的序列，每个元素有且只有一个前驱和一个 后继，表头和表尾元素分别无前驱和后继。 线性表数据元素的个数称为线性表的长度，长度为0的线性表称为空表 线性表的常用表达方式为：L=(a1,a2,a3,a4....an) 2.2.
数据结构基础知识——线性数据结构(向量、队列、栈)
Remoa的休闲茶馆
02-27 1375
数据结构基础知识 一、基础知识： 1、C++版框架； 2、C++结构体； 3、C++模板； 4、STL常用算法； 5、vector、set、queue； 二、应用实例 1、完数VS盈数【清华大学】； 2、约瑟夫entity【程序员代码面试指南】； 3、猫狗收容所【程序员面试金典】； 4、摆动序列【Leetcode】； 5、序列零-复杂性换位【上海交通大学】； 6、完成括号匹配【2018校招真题在线编程】； 7、堆栈的使用【吉林大学】； 8、计算表达式【上海交通大学】；
简单好用的单向队列
12-06
简单好用的单向队列,使用方便,可有效防止多线程漏与重复处理数据
单向循环.cpp
04-08
单向循环.cpp
数据结构与算法---链式存储结构（单向循环队列）
weixin_45404784的博客
12-17 422
定义 单向循环队列是基于链表实现的但是，与链表不同的是，此单向循环队列的头尾相连，即尾指针的后继是头结点。 空表状态 此单向循环队列采用真实头结点，所以此队列为空时head,rear均指向空。 public boolean isEmpty() { return size==0; } 添加元素 头插： 在头结点前面插入结点，即rear的后继为当前要插入的结点，当前要...
C++ 适配器 —— queue 单向队列
weixin_41565755的博客
05-04 452
1、queue queue<int> q; //查询元素 int a = q.front(); int b = q.back(); //增删元素 q.push(val); q.pop(); //大小判断 q.empty(); q.size(); 2、访问与查找中间元素 只能访问首尾元素（访问方式看接口），中间元素无法访问、查找。 需要访问...
c++实现单向循环链表
qq_36028321的博客
05-16 455
#include<iostream> using namespace std; template <class T> class Node { public: T data; Node<T>* next; }; template <class T> class CLinkList { public: CLinkList(); ~CLinkList(); int getLength() { return this->length; }; v
数据结构（C++）——单向循环链表
Anna的博客
01-20 445
#include"AllHead.h" template class CircList; template class CircListNode { friend class CircList; protected: T data; CircListNode *next; public: CircListNode(CircListNode *ptr = NULL){next = ptr
c实现单向循环列表
dabing113的博客
03-30 346
// // LinkList1.c // LinkList // //单向循环列表 #include <stdio.h> #define MaxSize 100 #define ElementType int typedef struct node{ ElementType data; struct node *link; }LNode,*LinkList; v...
c++ 实现栈、单向队列、双向队列
weixin_74385534的博客
06-09 462
栈与队列的学习
C++ 循环队列
qq_43650934的博客
12-13 2116
文章目录总结归纳代码实现 总结归纳 队列实际上就是现实生活中的排队，队头的人先走，新来的人排到队尾。先进先出，后进后出。 队列的实现，需要一个队头指针，一个队尾指针，用于入队和出队。对于循环队列，初始化时需将 Q.front = Q.rear = 0，Q.front 指向队头，Q.rear 指向新元素入队的位置。 循环队列，物理上仍然是申请一片连续的内存空间，但通过 (Q.rear + 1) % MaxSize == Q.front 的判断条件从逻辑上模拟环状空间，从而实现循环队列。 代码中值得一提的是
深入理解单向循环链表的C++实现与应用
在C++中，实现循环链表还需要考虑资源管理问题，如在插入或删除节点时要正确管理内存，避免内存泄漏。通常需要手动编写构造函数、析构函数、拷贝构造函数和赋值运算符等特殊成员函数来控制对象的创建和销毁过程。 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GXM.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值