C++ STL 【stack&queue】模拟实现

容器适配器

stack和queue为适配器，底层实现像反向迭代器，底层对其他容器进行封装，默认的容器为deque容器。
在stack和queue的类模板声明当中，第一个类型参数为存储在stack和queue的元素类型，第二个类型为stack和queue的存储容器类型，默认使用的是deque容器。

template <class T, class Container = deque<T> > class stack;

template <class T, class Container = deque<T> > class queue;

stack模拟实现

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

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

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

成员函数	函数作用
empty	判空操作
back	获取尾部元素操作
push_back	尾部插入元素操作
pop_back	尾部删除元素操作

4 .vector、list、deque容器都满足上述要求。

#include<vector>
#include<list>
#include<forward_list>
#include<deque>
#include<iostream>
using namespace std;
// 适配器模式
namespace BBQ
{
	// stack<int, vector<int>> s;
	// stack<int, list<int>> s;
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		bool empty() const
		{
			return _con.empty();
		}

		size_t size() const
		{
			return _con.size();
		}

		const T& top() const
		{
			return _con.back();
		}

		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}
	private:
		//vector<T> _v;
		Container _con;
	};
}

void test_stack()
	{
		// 后进先出 -- 不支持迭代器
		stack<int, std::vector<int>> s;
		stack<int, std::list<int>> s;
		stack<int> s;

		// 不支持string为容器
		stack<int, std::forward_list<int>> s;
		stack<int, string> s;
		stack<string, string> st;
		st.push("11111");// string容器的push_back只支持插入一个字符
		s.push(1);
		s.push(2);
		s.push(3);
		s.push(400);// int类型转换char发生截断
		while (!s.empty())
		{
			cout << s.top() << " ";
			s.pop();
		}
		cout << endl;
	}

queue模拟实现

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

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

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

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

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

#pragma once
#include<vector>
#include<list>
#include<forward_list>
#include<deque>
#include<iostream>
using namespace std;
namespace BBQ
{
	// stack<int, vector<int>> s;
	// stack<int, list<int>> s;
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		bool empty() const
		{
			return _con.empty();
		}

		size_t size() const
		{
			return _con.size();
		}

		const T& front() const
		{
			return _con.front();
		}

		const T& back() const
		{
			return _con.back();
		}

		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}
	private:
		Container _con;
	};
}

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

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

stack和queue选择使用deque的原因

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：
map为中控器，管理好每块空间。

deque的缺陷

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

与list比较，其底层是连续空间，空间利用率比较高（高速cache），不需要存储额外字段，无需频繁申请释放空间。

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。
1 . stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。
2. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。

总结一下：deque适合头尾插入删除，但是中间插入删除，和随机访问效率都差强人意。所以要高频随机访问还得是vector，要任意位置插入删除，还得是list。

完美结合，deque的优势刚好能满足stack和queue特性。