线性表（5）——队列——循环队列、链式队列、双端队列

最新推荐文章于 2024-03-20 15:23:23 发布
最新推荐文章于 2024-03-20 15:23:23 发布
阅读量292 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805255/article/details/88750518
版权
本文详细介绍了如何使用C++实现三种队列结构：循环队列，包括Queue.h、Array_Queue.h和main.cpp的实现；链式队列，基于Queue.h，同时提供了Link_Queue.h和main.cpp的代码；以及双端队列的概念。
摘要由CSDN通过智能技术生成

1.循环队列

C++实现：

Queue.h

#pragma once
#ifndef QUEUE_H
#define QUEUE_H
template <typename T>
class Queue
{
public:
	//Queue数据类型表
	typedef T Value_Type;
	typedef T& Value_Reference;
	typedef T* Value_Pointer;
	typedef const T& Const_Value_Reference;
	typedef const Queue& Const_Queue_Reference;

private:
	//重载赋值运算符
	void operator=(Const_Queue_Reference) {}
	//拷贝构造函数
	Queue(Const_Queue_Reference) {}

public:
	//默认构造函数
	Queue() {}
	//析构函数
	virtual ~Queue() {}
	//清空栈
	virtual void clear() = 0;
	//入队
	virtual void enter_Queue(Const_Value_Reference) = 0;
	//出栈
	virtual  Value_Type out_Queue() = 0;
	//返回栈的头部的值
	virtual Const_Value_Reference front_Value()  = 0;
	//栈的长度
	virtual int length()const = 0;
};

Array_Queue.h

#pragma once
#include "Queue.h"
#include <iostream>
#include <string>
#define DEFAULT_SIZE 100
template <typename T>
class Array_Queue :public Queue<T>
{
public:
	//Array_Queue数据类型表
	typedef T Value_Type;
	typedef T& Value_Reference;
	typedef T* Value_Pointer;
	typedef const T& Const_Value_Reference;
	typedef const Array_Queue& Const_Array_Queue_Reference;
private:
	int array_Size;  //创建栈时申请的内存空间大小
	int front;       //指向队头元素的指针
	int rear;        //指向队尾元素的指针
	Value_Type* list_Array; //实现栈的数组

	//满足某种异常条件，抛出异常，打印错误信息
	void judge_OutOfRange(bool condition, const std::string& printInfo)
	{
		try
		{
			if (condition)
			{
				throw condition;
			}
		}
		catch (bool)
		{
			std::cerr << printInfo << std::endl;
			exit(1);
		}
	}
public:
	//默认构造函数
	Array_Queue(int size = DEFAULT_SIZE)
	{
		array_Size = size+1;
		rear = 0;
		front = 1;
		list_Array = new Value_Type[array_Size];
	}

	//析构函数
	~Array_Queue()
	{
		delete[] list_Array;
	}

	//清空队列
	void clear() override
	{
		rear = 0;
		front = 1;
	}

	//入队
	void enter_Queue(Const_Value_Reference value) override
	{
		judge_OutOfRange((rear+2)%array_Size==front, "Array Queue is full!");
		rear = (rear + 1) % array_Size;
		list_Array[rear]=value;
	}

	//出队
	Value_Type out_Queue() override
	{
		judge_OutOfRange(length()==0, "Array Queue is empty!");
		Value_Type return_Value = list_Array[front];
		front = (front + 1) % array_Size;
		return return_Value;
	}

	//返回队首元素的值
	Const_Value_Reference front_Value()  override
	{
		judge_OutOfRange(length() == 0, "Array Queue is empty!");
		return list_Array[front];
	}

	//队的长度
	int length()const override
	{
		int return_length = (array_Size + (rear - front) + 1) % array_Size;
		//解释：
		//	1.rear与front的关系可能是
		//		（1）front在数组下标大的一端，rear在小的一端：rear-front就会为负，
		//		 当加上array_Size取余就变成了数组中除去rear到front之间的元素的剩余元素的长度了，
		//		（2）front在数组下标大的一端，rear在小的一端：rear-front就会为正
		//		当加上array_Size取余还是rear之间front的长度
		//	2.加1是因为两数相减的长度中不包含一端本身的值，比如5-3=2，但是5，4，3有三个值
		//	  即rear-front的长度不算front本身，所以加1
		return return_length;
	}

	void print()
	{
		int i = front;
		while (i != rear + 1)
		{
			std::cout << list_Array[i] << std::endl;
			i = (i + 1) % array_Size;
		}
	}
};

main.cpp

#include <iostream>
#include "Array_Queue.h"
using namespace std;
int main()
{
	Array_Queue<int> test_queue;
	cout << "测试enter_Queue" << endl;
	test_queue.enter_Queue(10);
	test_queue.enter_Queue(20);
	test_queue.enter_Queue(20);
	test_queue.enter_Queue(30);
	test_queue.enter_Queue(40);
	cout << "出队前遍历：" << endl;
	test_queue.print();
	cout << "出队前队列长度" << endl;
	cout << test_queue.length() << endl;

	cout << "测试out_Queue" << endl;
	cout << test_queue.out_Queue() << endl;
	cout << "出队后遍历：" << endl;
	test_queue.print();
	cout << "出队后队列长度" << endl;
	cout << test_queue.length() << endl;

	cout << "测试front_Value" << endl;
	cout << test_queue.front_Value() << endl;

	cout << "测试clear" << endl;
	test_queue.clear();
	cout << test_queue.length() << endl;
}

2.链式队列

C++实现：

Queue.h

同上

Link_Queue.h

#pragma once
#ifndef LINK_QUEUE_H
#define LINK_QUEUE_H
#include "Single_Link_List_Node.h"
#include "Queue.h"
#include<iostream>
#include<string>

//带头结点的链表：出队是在操作front->next
template<typename T>
class Link_Queue:public Queue<T>
{
public:
	typedef T Value_Type;
	typedef T& Value_Type_Reference;
	typedef const T& Const_Value_Type_Reference;
	typedef Single_Link_List_Node<T>  Node;
	typedef Single_Link_List_Node<T>* Front;
	typedef Single_Link_List_Node<T>* Rear;
private:
	Front front;
	Rear rear;
	int size;

	//满足某种异常条件，抛出异常，打印错误信息
	void judge_OutOfRange(bool condition, const std::string& printInfo)
	{
		try
		{
			if (condition)
			{
				throw condition;
			}
		}
		catch (bool)
		{
			std::cerr << printInfo << std::endl;
			exit(1);
		}
	}
public:
	//构造函数
	Link_Queue()
	{
		front = rear = new Node;
		size = 0;
	}
	//析构函数
	~Link_Queue()
	{
		clear();
		delete front;
	}
	//清空队列
	void clear() override
	{
		while (front->next != nullptr)
		{
			Node* temp = front->next;
			front->next = temp->next;
			delete temp;
		}
		rear = front;
		size = 0;
	}
	//入队
	void enter_Queue(Const_Value_Type_Reference value) override
	{
		rear->next = new Node;  //新建结点分配内存
		::new(rear->next)Node(value,nullptr); //调用构造函数
		rear = rear->next;
		size++;
	}

	//出队
	Value_Type out_Queue() override
	{
		judge_OutOfRange(length() == 0,"Queue is empty!");
		Value_Type return_value = front->next->value;

		Node* temp = front->next;
		front->next= front->next->next;
		if (rear == temp)
			rear = front;
		delete temp;
		size--;
		return return_value;
	}
	//返回队首元素的值
	Const_Value_Type_Reference front_Value() override
	{
		judge_OutOfRange(length() == 0, "Array Queue is empty!");
		return front->next->value;
	}

	//队的长度
	int length()const override
	{
		return size;
	}

	//遍历打印队列中值
	void print()
	{
		Node* temp = front->next;
		while (temp!=nullptr)
		{
			std::cout << temp->value << std::endl;
			temp = temp->next;
		}
	}

};
#endif // !LINK_QUEUE_H

main.cpp

#include <iostream>
#include "Link_Queue.h"
using namespace std;
int main()
{
	Link_Queue<int> test_queue;
	cout << "测试enter_Queue" << endl;
	test_queue.enter_Queue(10);
	test_queue.enter_Queue(20);
	test_queue.enter_Queue(20);
	test_queue.enter_Queue(30);
	test_queue.enter_Queue(40);
	cout << "出队前遍历：" << endl;
	test_queue.print();
	cout << "出队前队列长度" << endl;
	cout << test_queue.length() << endl;

	cout << "测试out_Queue" << endl;
	cout << test_queue.out_Queue() << endl;
	cout << "出队后遍历：" << endl;
	test_queue.print();
	cout << "出队后队列长度" << endl;
	cout << test_queue.length() << endl;

	cout << "测试front_Value" << endl;
	cout << test_queue.front_Value() << endl;

	cout << "测试clear" << endl;
	test_queue.clear();
	cout << test_queue.length() << endl;
}

3.双端队列

 

喵的波波鱼
关注
专栏目录
【数据结构】队列-顺序队列、循环队列、链队、双端队列
Sicilly的博客
07-24 1309
定义 队列是只允许在一端进行插入，而在另一端进行删除的线性表。 队头（Front）：允许删除的一端，又称为队首。 队尾（Rear）： 允许插入的一端。 先进入队列的元素必然先离开队列，即先进先出（First In First Out）简称FIFO。 **对比：**栈中元素后进去的必然先出来，即后进先出LIFO（Last In First Out）。 顺序队列 用数组来实现队列，可以将队首放在数组下...
特殊队列(循环与双端)
weixin_55742319的博客
01-15 281
特殊队列(循环队列与双端队列)
循环队列和循环双端队列
派拉斯兔子的博客
11-03 567
循环队列（Circular Queue） 循环队列底层用数组实现。 循环双端队列：可以进行两端添加、删除操作的循环队列 队列底层也可以使用动态数组实现，并且各项接口也可以优化到O(1)的时间复杂度这个用数组实现优化之后的队列也叫做：循环队列。 上述图示： ①、front == tail时队列为空 ②、front==(tail + 1) % c队列为满 ③、capacity中，浪费一个空间 package com.mj.circle; public class CircleQueue<E&gt
循环队列与双端队列
MJ6666666的博客
01-14 641
ArrayQueue 队列的顺序存储结构本身是由ArrayList实现的 在数据元素入队的时候，相对于在ArrayList表尾添加元素 在数据元素出队的时候，相当于在ArrayList表头删除元素 很明显，入队的时间复杂度O(1)，出队的时间复杂度为O(n) 线性表增删数据元素时间复杂符都是O(n)，但是这个是按平均算的 队列的出队时间复杂度O(n)，可不是按平均算的，因为每次出队都是O(n） 循环队列ArrayLoopQueue 该循环队列的实现思想也是动态数组 但是由于操作元素的特殊性，并不能直接由Ar
数据结构之循环双端队列
weixin_48492905的博客
11-04 1611
循环双端队列和循环队列在实现上几乎是一样的，需要注意的有以下几点： 1、定义循环变量 front 和 rear 。一直保持这个定义，到底是先赋值还是先移动指针就很容易想清楚了。 ① front：指向队列头部第 1 个有效数据的位置； ② rear：指向队列尾部（即最后 1 个有效数据）的下一个位置，即下一个从队尾入队元素的位置。 2、为了避免“队列为空”和“队列为满”的判别条件冲突，我们有意浪费了一个位置。浪费一个位置是指：循环数组中任何时刻一定至少有一个位置不存放有效元素。 上图所示情况，我们就可以判定
线性表——队列
m0_68989458的博客
05-11 201
队列的使用
【数据结构】受限制的线性表——队列
最新发布
HD_13的博客
03-20 2465
上一章我们讲了一种特殊的线性表只能在表尾进行插入和删除操作，接下来我们讲一个和栈很相似的数据结构，它也是一种特殊且所限制的线性表，它是只能在表头删除操作在表尾进行插入操作。
数据结构：线性表、链表、队列、栈、串
11-24
在实际编程中，C++提供了标准模板库（STL），其中的`std::vector`可以作为线性表的实现，`std::list`作为链表，`std::deque`作为双端队列，`std::stack`作为栈。这些容器提供了丰富的接口，简化了数据结构的使用。 ...
数据结构笔记：双端队列
01-21
双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间 双端队列的实现 通过...
队列---双端队列与循环队列
m0_46657493的博客
03-23 509
接口与类的继承关系： 双端队列 双端队列：两端都可以进行入队和出队操作的队列 Deque接口—>LinkedList(实现类) 公共方法：isEmpty() / size() / contains() … 当栈使用时： 压栈：push(e) 查看栈顶元素：peek() 弹出栈顶元素：pop() 当单向队列使用时： 插入队列：add(e) 查看队首元素：element() 取出队首元素：remove() 方法： 方法 解释 addFirst(e) / ofterFirs
双向循环队列
05-05
双向循环队列的进出队列，每个元素表示一个待处理的作业。元素值表示作业的预计时间，若一个新提交作业的预计执行时间小于队头和队尾作业的平均时间，则插在队头，否则插入队尾。
双端循环队列——Letcode641.Design Circular Deque
sHuXnHs
12-18 801
1.题目 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。 dele...
队列，双端队列，循环队列，循环双端队列的含义与关系
Mrrr_Li的博客
11-30 366
队列：LinkedList，ArrayDeque 双端队列：（LinkedList，ArrayDeque） 循环队列：是一种底层用动态数组实现的队列 循环双端队列：可以进行两端添加删除的循环队列
双端循环队列
liudaoqiang_tj的博客
12-11 348
typedef struct QueElemTag{ QueElemTypeAlias* next; QueElemTypeAlias* prev; int value; }QueElemTypeAlias; #define QUEUEREMOVE(elem){\ ((QueElemTypeAlias*)elem)-&gt;prev-&gt;next = ((QueElemTypeAl...
循环队列、双端队列
NorthSmile的博客
05-05 705
循环队列、双端队列
pta6-15（双端循环队列）
weixin_34392435的博客
03-06 182
题目链接：https://pintia.cn/problem-sets/1101307589335527424/problems/1101313244863737856 题意：实现双段队列的队首出队、入队以及队尾出队、入队4个操作 思路： 根据裁判测试程序我们可以发现，在CreateDeque函数中将MaxSize加了1，而且这里的MaxSize定义的是最大容量，所以这是一个循环队列，且为了...
双端队列
一只秀逗__的博客
08-13 341
头文件  deque&lt;类型&gt;d;  可以用d[i]访问元素。  常用于SPFA的SLF优化。 函数：  push_back(x)/push_front(x) //把x压入后/前端  back()/front() //访问(不删除)后/前端元素  pop_back() pop_front() //删除后/前端元素  empty() //判断deque是否空  size() //返回de...
LeetCode 641. 设计循环双端队列
yj_coder的博客
05-02 285
题目描述 设计实现双端队列。 你的实现需要支持以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。 insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。...
java数据结构学习-双端队列,循环队列
06-27 347
双端队列是能在头尾两端添加,删除的队列(Deque) 代码实现: /** * 双端队列的实现 */ public class Deque<E> { private List<E> list = new LinkedList<>(); public int size(){ return list.size(); }...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值