stack(栈)和queue(队列)

1.stack的介绍和使用(栈)

1.1 stack的介绍

1.2 stack的使用

1.3stack的模拟实现

2.queue的介绍和使用(队列)

2.1queue的介绍

2.3queue的模拟实现

3.priority_queue的介绍和使用

3.1priority_queue的介绍

3.2 priority_queue的使用

3.3priority_queue的模拟实现

4.容器适配器

4.1什么是容器适配器

4.2STL标准库中stack和queue的底层结构

4.3deque(双端队列)的简单介绍

4.3.1deque原理介绍

4.3.2deque的缺陷

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

1.stack的介绍和使用(栈)

1.1 stack的介绍

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

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

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

back：获取尾部元素操作

push_back：尾部插入元素操作

pop_back：尾部删除元素操作

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

1.2 stack的使用

函数声明	接口说明
stack()	构造空的栈
empty()	检测stack是否为空
size()	返回stack中元素的个数
top()	返回栈顶元素的引用
push()	将元素val压入stack中
pop()	将stack中尾部的元素弹出

1.3stack的模拟实现

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack,所以stack的底层也可以使用vector来充当，不过这里使用的是deque为了和库里的保持一致。

//stack.h
namespace bit
{
	template<class T, class Container = deque<T>> //Container - 容器
	class stack//容器适配器
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		T& top()
		{
			return _con.back();
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

//main.cpp
#define _CRT_SECURE_NO_WARNINGS 1

#include"stack.h"
#include"queue.h"

void test_stack()
{
	bit::stack<int, vector<int>> st1;
	st1.push(1);
	st1.push(2);
	st1.push(3);
	st1.push(4);

	while (!st1.empty())
	{
		cout << st1.top() << " ";
		st1.pop();
	}
	cout << endl;

	bit::stack<int, list<int>> st2;
	st2.push(1);
	st2.push(2);
	st2.push(3);
	st2.push(4);

	while (!st2.empty())
	{
		cout << st2.top() << " ";
		st2.pop();
	}
	cout << endl;
}

int main()
{
	test_stack();
    
	return 0;
}

2.queue的介绍和使用(队列)

2.1queue的介绍

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
empty：检测队列是否为空
size：返回队列中有效元素的个数
front：返回队头元素的引用
back：返回队尾元素的引用
push_back：在队列尾部入队列
pop_front：在队列头部出队列
4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

函数声明	接口说明
queue()	构造口的队列
empty()	检测队列是否为空，返回true，否则返回false
size()	返回队列中有效元素的个数
front()	返回队头元素的引用
back()	返回队尾元素的引用
push()	在队尾将元素val入队列
pop()	将队头元素出队列

2.3queue的模拟实现

因为queue的接口中存在头删和尾插，因此使用vector来封装效率太低，故可以借助list来模拟实现queue，不过这里使用的是deque为了和库里的保持一致，具体如下：

//queue.h
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include<list>
#include<vector>

using namespace std;

namespace bit
{
	template<class T, class Container = deque<T>> //Container - 容器
	class queue//容器适配器
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_front();
		}
		T& front()
		{
			return _con.front();
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

//main.cpp
#define _CRT_SECURE_NO_WARNINGS 1

#include"stack.h"
#include"queue.h"

void test_queue()
{
	bit::queue<int, list<int>> q;

	//queue<int, vector<int>> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);

	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
}

int main()
{
	test_queue();
	return 0;
}

3.priority_queue的介绍和使用

3.1priority_queue的介绍

1. 优先级队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。(默认)
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先级队列中位于顶部的元素)。
3. 优先级队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先级队列的顶部。
4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素

pop_back()：删除容器尾部元素
5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

3.2 priority_queue的使用

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

函数声明	接口说明
explicit priority_queue<类型> (); / explicit priority_queue<int, 随机容器<int>, greater<int>> (); 注：可以进行随机访问的容器如：vector和deque	1.构造一个空的优先级队列(大堆) / (小堆) 2.参数可以使用某一个对象的区间的迭代器进行构造优先级队列
empty()	检测优先级队列是否为空，是返回true，否则返回false
top()	返回优先级队列中最大(最小元素)，即堆顶元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大(最小)元素，即堆顶元素

3.3priority_queue的模拟实现

//priority_queue.h
#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include<iostream>
using namespace std;
#include<vector>
#include <utility>
#include<algorithm>

//仿函数/函数对象
//这个类对象可以像函数一样使用 -- 仿函数
//本质上就是一个类(类对象)，只不过重载 () 之后能和函数一样使用
template<class T>
class Less
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};
namespace bit
{
	//Comapre是一个函数类型(仿函数), less(小)和greater(大)都是一个库函数
	template<class T, class Container = vector<T>, class Comapre = less<T>>
	class priority_queue
	{
	private:
		void AdjustDonw(int parent)
		{
			Comapre com;
			int child = parent * 2 + 1;

			while (child < _con.size())
			{
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
					++child;

				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}
		}

		void AdjuseUP(int child)
		{
			Comapre com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child] , _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
					break;
			}
		}

	public:
		priority_queue()
		{}

		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)//使用一段区间来初始化优先级队列
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}

			//建大堆
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
			{
				AdjustDonw(i);
			}
		}

		void push(const T& x)
		{
			_con.push_back(x);
			AdjuseUP(_con.size() - 1);
		}
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			AdjustDonw(0);
		}
		const T& top() const
		{
			return _con[0];
		}
		bool empty() const
		{
			return _con.empty();
		}
		size_t size()const
		{
			return _con.size();
		}
	private:
		Container _con;
	};
}

//main.cpp
#define _CRT_SECURE_NO_WARNINGS 1

#include "priority_queue.h"
#include<queue>
void test_priority_queue()
{
	bit::priority_queue<int, vector<int>, Less<int>> pq;

	pq.push(1);
	pq.push(2);
	pq.push(3);
	pq.push(4);

	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}

int main()
{
	test_priority_queue();
	return 0;
}

4.容器适配器

4.1什么是容器适配器

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

4.2STL标准库中stack和queue的底层结构

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

4.3deque(双端队列)的简单介绍

4.3.1deque原理介绍

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

deque （双端队列）的实现通常采用了一个中央控制器（central control block）和多个缓冲区（buffer）的结构。

中央控制器：中央控制器是 deque 的核心，它负责维护和管理所有缓冲区，以及记录 deque 的大小和迭代器等相关信息。中央控制器通常包含一个指向第一个缓冲区的指针和一个指向最后一个缓冲区的指针。
缓冲区：缓冲区是实际存储元素的连续内存块。每个缓冲区通常被实现为一个数组（或类似数组的结构），用于存储元素。缓冲区还包含指向前一个缓冲区和后一个缓冲区的指针，以及记录当前缓冲区使用情况的指针。

在 deque 的实现中，需要考虑以下几个关键操作：

在前端插入元素：当在 deque 的前端插入元素时，中央控制器会检查第一个缓冲区是否有足够的空间，如果没有，则需要分配一个新的缓冲区，并将其插入到前端位置。
在后端插入元素：当在 deque 的后端插入元素时，中央控制器会检查最后一个缓冲区是否有足够的空间，如果没有，则需要分配一个新的缓冲区，并将其插入到后端位置。
在前端删除元素：当在 deque 的前端删除元素时，中央控制器会检查第一个缓冲区是否变为空，如果是，则需要释放该缓冲区，并将第二个缓冲区设置为新的第一个缓冲区。
在后端删除元素：当在 deque 的后端删除元素时，中央控制器会检查最后一个缓冲区是否变为空，如果是，则需要释放该缓冲区，并将倒数第二个缓冲区设置为新的最后一个缓冲区。

通过这样的实现，deque 可以在两端高效地进行插入和删除操作，同时支持随机访问。每个缓冲区的大小通常会根据实现进行调整，以平衡空间利用率和性能。

需要注意的是，作为C++标准库的一部分，deque 的实现可能在不同的编译器和库中有所差异，但通常都遵循上述的基本原理和当涉及到更具体的 deque 实现时，有几种常见的方法：

双端数组（Double-ended array）：这种实现方法使用一个动态分配的数组来存储元素。当在 deque 的前端或后端插入或删除元素时，数组的大小可能会动态调整。为了支持在两端高效插入和删除元素，数组可能会被重新分配和移动。这种实现方法的优点是在空间和时间上都能提供较好的性能，同时支持随机访问。但是，当需要重新分配数组时，插入或删除操作的复杂度可能会达到线性级别。
块（Chunk）：这种实现方法将元素存储在一系列固定大小的块中，每个块包含一定数量的元素。每个块都有指向前一个块和后一个块的指针。当在 deque 的前端或后端插入或删除元素时，可能需要重新分配和移动块。这种实现方法的优点是在插入或删除操作时可以实现较好的性能，但随机访问的性能可能较差。
双向链表（Doubly-linked list）：这种实现方法使用双向链表来存储元素。每个节点包含一段固定大小的缓冲区，按需分配和释放。每个节点都有指向前一个节点和后一个节点的指针，以及指向缓冲区的指针。这种实现方法的优点是在插入或删除操作时可以实现较好的性能，但随机访问的性能较差。

需要注意的是，以上所述的实现方法只是一种示例，并不代表所有实际实现中都是如此。在实际的编译器和库中，可能会使用其他方法或对这些方法进行优化和组合，以在性能和空间利用方面达到最佳平衡。此外，不同的编译器和库也可能有自己的实现细节和策略。因此，具体的 deque 实现可能会因不同的环境而有所差异。

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

4.3.2deque的缺陷

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不
需要搬移大量的元素，因此其效率是必vector高的。与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

deque内部结构包含中央控制器和缓冲区数组。中央控制器负责记录缓冲区数组的状态和连接关系，而缓冲区数组实际存储了deque的元素。

在使用[]操作获取指定位置的元素时，deque会先通过中央控制器找到对应的缓冲区块，然后再在该块中找到目标位置的元素。具体的过程如下：

根据指定位置，deque会计算出目标元素所在的缓冲区块的索引。
中央控制器会根据缓冲区块的索引和连接关系，定位到对应的缓冲区块。
在该缓冲区块中，deque会按照元素的顺序依次遍历，直到找到目标位置的元素或遍历完该块。
如果在遍历的过程中找到了目标位置的元素，则返回该元素；否则，在遍历完所有块后返回错误或默认值。

可以看到，deque的[]操作需要通过中央控制器来定位到具体的缓冲区块，然后再在该块中进行遍历查找。这种设计在一定程度上增加了遍历的成本，导致时间复杂度为O(n)。

4.4 为什么选择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的优点，而完美的避开了其缺陷。