• 【C++】stack & queue

    stack & queue

    一、容器适配器

    适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成我们希望的另外一个接口。

    虽然 stack 和 queue 中也可以存放元素，但在 STL 中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为 stack 和 queue 只是对其他容器的接口进行了包装，STL 中 stack 和queue 默认使用 deque（后面介绍）， 比如：

    在这里插入图片描述

    在这里插入图片描述

    其实容器适配器就是复用其他容器，利用其他容器的功能来适配出一个新的容器。

    二、deque（了解）

    deque(双端队列)： 是一种双开口的 “连续” 空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为 O(1)，与 vector 比较，头插效率高，不需要搬移元素；与 list 比较，空间利用率比较高。如果需要高效的随机存取，还要大量的首尾的插入删除则建议使用 deque.

    deque 并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际 deque 类似于一个动态的二维数组，其底层结构如下图所示：

    在这里插入图片描述

    与 vector 比较，deque 的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是比 vector 高的；

    与 list 比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段；

    但是，deque 有一个致命缺陷：不适合遍历，因为在遍历时，deque 的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑 vector 和 list，deque 的应用并不多，而目前能看到的一个应用就是，STL 用其作为 stack 和 queue 的底层数据结构。

    那么为什么选择 deque 作为 stack 和 queue 的底层默认容器呢？

    stack 是一种后进先出的特殊线性数据结构，因此只要具有push_back() 和 pop_back() 操作的线性结构，都可以作为 stack 的底层容器，比如 vector 和 list 都可以；

    queue 是先进先出的特殊线性数据结构，只要具有 push_back 和 pop_front 操作的线性结构，都可以作为 queue 的底层容器，比如 list。但是 STL 中对 stack 和 queue 默认选择 deque 作为其底层容器，主要是因为：

    1. stack 和 queue 不需要遍历 (因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。
    2. 在 stack 中元素增长时，deque 比 vector 的效率高(扩容时不需要搬移大量数据)；queue 中的元素增长时，deque 不仅效率高，而且内存使用率高。结合了 deque 的优点，而完美的避开了其缺陷。

    三、stack

    1. stack 的介绍

    我们先可以看一下 stack 的文档介绍：stack.

    1. stack 是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

    2. stack 是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

    3. stack 的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

       		empty：判空操作
 		back：获取尾部元素操作
 		push_back：尾部插入元素操作
 		pop_back：尾部删除元素操作

      • 1
      • 2
      • 3
      • 4

    4. 标准容器 vector、deque、list 均符合这些需求，默认情况下，如果没有为 stack 指定特定的底层容器，默认情况下使用 deque.

    我们先简单地看看 stack 的使用：

    		void test_stack()
		{
			stack st;
			st.push(1);
			st.push(2);
			st.push(3);
			st.push(4);
			st.push(5);
			while (!st.empty())
			{
				cout << st.top() << ' ';
				st.pop();
			}
			cout << endl;
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    运行结果如下：

    在这里插入图片描述

    2. 模拟实现 stack

    我们使用 deque 作为 stack 的适配器模拟实现：

    		#pragma once
		#include 
		#include 
		
		namespace Young
		{
			template >
			class Stack
			{
			public:
				// 入栈
				void push(const T& val)
				{
					_con.push_back(val);
				}
		
				// 出栈
				void pop()
				{
					_con.pop_back();
				}
		
				// 获取栈顶元素
				T& top()
				{
					return _con.back();
				}
		
				// const 对象获取栈顶元素
				const T& top() const
				{
					return _con.back();
				}
				
				// 获取栈的大小
				size_t size()
				{
					return _con.size();
				}
		
				// 判断栈是否为空
				bool empty()
				{
					return _con.empty();
				}
		
			private:
				Container _con;
			};
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    如上，stack 的常用接口就实现好了，我们再用我们自己实现的 stack 测试一下：

    在这里插入图片描述

    四、queue

    1. queue 的使用

    我们先看一下 queue 的文档介绍：queue.

    1. 队列是一种容器适配器，专门用于在 FIFO 上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

    2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue 提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

    3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

       		empty：检测队列是否为空
 		size： 返回队列中有效元素的个数
 		front：返回队头元素的引用
 		back： 返回队尾元素的引用
 		push_back：在队列尾部入队列
 		pop_front：在队列头部出队列

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    4. 标准容器类 deque 和 list 满足了这些要求。默认情况下，如果没有为 queue 实例化指定容器类，则使用标准容器 deque.

    先简单看一下 queue 的使用：

    		void test_queue()
		{
			queue q;
			q.push(1);
			q.push(2);
			q.push(3);
			q.push(4);
			q.push(5);
			while (!q.empty())
			{
				cout << q.front() << ' ';
				q.pop();
			}
			cout << endl;
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    运行结果如下：

    在这里插入图片描述

    2. 模拟实现 queue

    我们也使用 deque 适配 queue：

    		#pragma once
		#include 
		
		
		namespace Young
		{
			template>
			class Queue
			{
			public:
				// 入队列
				void push(const T& val)
				{
					_con.push_back(val);
				}
		
				// 出队列
				void pop()
				{
					_con.pop_front();
				}
		
				// const 对象获取队头元素
				const T& front() const
				{
					return _con.front();
				}
		
				// 获取队头元素
				T& front()
				{
					return _con.front();
				}
		
				// const 对象获取队尾元素
				const T& back() const
				{
					return _con.back();
				}
		
				// 获取队尾元素
				T& back()
				{
					return _con.back();
				}
		
				// 获取队列长度
				size_t size()
				{
					return _con.size();
				}
		
				// 判断队列是否空
				bool empty()
				{
					return _con.empty();
				}
			private:
				Container _con;
			};
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    我们再使用自己实现的 queue，来测试一下：

    在这里插入图片描述

    3. priority_queue

    （1）priority_queue 的介绍

    priority_queue：优先级队列，是属于队列的一种，我们先看一下它的文档介绍 priority_queue.

    1. 优先级队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

    2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先级队列中位于顶部的元素)。

    3. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

       		empty()：检测容器是否为空
 		size()： 返回容器中有效元素个数
 		front()：返回容器中第一个元素的引用
 		push_back()：在容器尾部插入元素
 		pop_back()： 删除容器尾部元素

      • 1
      • 2
      • 3
      • 4
      • 5

    4. 标准容器类 vector 和 deque 满足这些需求。默认情况下，如果没有为特定的 priority_queue 类实例化指定容器类，则使用vector。

    5. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、push_heap 和 pop_heap 来自动完成此操作。

    （2）priority_queue 的使用

    优先级队列默认使用 vector 作为其底层存储数据的容器，在 vector 上又使用了堆算法将 vector 中元素构造成堆的结构，因此 priority_queue 就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下 priority_queue 是大堆。

    在这里插入图片描述

    注意，我们看文档，默认情况下 priority_queue 是大堆，但是上图中红框中的是一个仿函数（后面介绍），就是实现比较的，其中 less 有小的意思，但是它却实现成大堆，这里要注意。其次，我们使用默认的参数时，只需要传第一个参数即可，后面的使用缺省参数即可，但是我们需要使用小堆的时候就需要将全部参数都传进去；我们先来看看使用：

    		#include 
		#include 
		#include  // greater算法的头文件
		void TestPriorityQueue()
		{
			// 默认情况下，创建的是大堆，其底层按照小于号比较
			vector v{ 3,2,7,6,0,4,1,9,8,5 };
		
			priority_queue q1;
			for (auto& e : v)
				q1.push(e);
		
			cout << q1.top() << endl;
		
		
			// 如果要创建小堆，将第三个模板参数换成 greater 比较方式
			priority_queue, greater> q2(v.begin(), v.end());
			cout << q2.top() << endl;
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    运行结果如下：

    在这里插入图片描述

    （3）仿函数

    仿函数又称为函数对象，是一个能行使函数功能的类。它的使用和我们平时的函数调用一样。

    首先我们得先实现一个类，这个类中需要实现 () 运算符重载，里面实现的功能需要我们自己实现，假设我们需要实现 priority_queue 中的大堆，如下：

    		// 仿函数 --- 大堆，大的优先级大
		template 
		class Less
		{
		public:
			bool operator()(const T& x, const T& y)
			{
				return x < y;
			}
		};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    那么如何调用呢？首先我们得先创建一个对象，再使用这个对象进行调用函数：

    			Less less;
			cout << less(1, 8) << endl; // 与下等价
			cout << less.operator()(1, 8) << endl;

    • 1
    • 2
    • 3

    运行结果如下：

    在这里插入图片描述

    下面我们使用仿函数的形式模拟实现 priority_queue.

    （4）模拟实现 priority_queue

    	#pragma once
	#include 
	
	namespace Young
	{
		// 模板参数
		template , class Compare = Less>
		class PriorityQueue
		{
		public:
			// 向上调整 --- 大堆
			void adjust_up(size_t child)
			{
				Compare com;
				size_t parent = (child - 1) / 2;
				while (child > 0)
				{
					//if (_con[parent] < _con[child]) // 与下等价
					if (com(_con[parent], _con[child]))
					{
						swap(_con[child], _con[parent]);
						child = parent;
						parent = (child - 1) / 2;
					}
					else
					{
						break;
					}
				}
			}
	
			// 向下调整 --- 大堆
			void adjust_down(size_t parent)
			{
				Compare com;
				size_t child = parent * 2 + 1;
				
				while (child < _con.size())
				{
					if (child + 1 < _con.size() && _con[child + 1] > _con[child])
					{
						++child;
					}
	
					// if (_con[parent] < _con[child])  // 与下等价
					if (com(_con[parent], _con[child]))
					{
						swap(_con[child], _con[parent]);
						parent = child;
						child = parent * 2 + 1;
					}
					else
					{
						break;
					}
				}
			}
	
			// 入数据
			void push(const T& val)
			{
				_con.push_back(val);
				adjust_up(_con.size() - 1);
			}
	
			// 出数据
			void pop()
			{
				swap(_con[0], _con[_con.size() - 1]);
				_con.pop_back();
	
				adjust_down(0);
			}
	
			// 获取优先级最大的数据
			const T& top()
			{
				return _con.front();
			}
	
			// 判空
			bool empty()
			{
				return _con.empty();
			}
	
		private:
			Container _con;
		};
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90

    下面我们使用自己实现的优先级队列进行测试：

    		void test_priority_queue()
		{
			// Young::PriorityQueue, Greater> pq; // 小堆
		
			// Young::PriorityQueue, Less> pq; // 大堆，与下等价
			Young::PriorityQueue pq;  // 缺省参数默认是大堆
			pq.push(2);
			pq.push(8);
			pq.push(1);
			pq.push(0);
			pq.push(10);
		
			while (!pq.empty())
			{
				cout << pq.top() << ' ';
				pq.pop();
			}
		
			cout << endl;
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    测试结果如下：

    在这里插入图片描述

  • 相关阅读:
    数据结构与算法基础-学习-04-线性表之链式表-查找元素返回位置、查找元素返回指针、插入元素等实现
    认证学习5 - Cookie、会话认证讲解、代码实现、演示
    C/C++好题分享--代码题
    Milk Scheduling S——拓扑排序
    mybatisPlus逻辑删除注解@TableLogic
    VuePress 博客之 SEO 优化（五）添加 JSON-LD 数据
    批量删除wordpress文章修订版本/自动草稿残留数据（3种方法）及四种方法禁用WordPress文章历史修订/自动保存/自动草稿功能
    【浅学Java】Linux常用命令
    C专家编程 第8章 为什么程序员无法分清万圣节和圣诞节 8.2 根据位模式构筑图形
    some数组遍历
  • 原文地址：https://blog.csdn.net/YoungMLet/article/details/133272448