STL deque与常见的容器适配器 stack、 queue、 priority_queue

deque

1. deque双端队列是动态大小的序列式容器，其可以向两端进行伸缩。
2. 特定的库可以以不同的方式实现deque，但通常都是一种动态数组。不论在何种情况下，它都允许通过随机访问迭代器直接访问单个元素，可以根据需要动态的伸缩。
3. 因此，deque提供了一些与vector相似的功能，但deque在头部和尾部进行数据插入和删除操作更加高效。与vector不同的是，deque不能保证所有的元素存储在连续的空间中，在deque中通过指针加偏移量方式访问元素可能会导致非法的操作。
4. vector与deque提供了相似的接口，因此其具有类似的用途，但是内部的实现原理不同：vector使用使用了动态数组，该数组通常需要动态增长；deque中的元素可能分散在不同的存储块中，在deque中保存了一些必要的信息，通常用来在常数范围内直接访问deque中的任何一个元素，所以deque的内部实现比vector复杂，但是这些额外信息使得dque在某些情况下增长更加的高效，特别是在序列比较大，重新分配成本比较高的情况下。
5. 除了在频繁在头部或尾部进行插入和删除操作外，deque比list的性能更差。
6. 且deque中排序操作的效率是非常低的，当对deque进行sort排序时，需要多次对deque中的元素进行整体遍历，而deque中的元素整体遍历时效率比较低，这是因为deque底层的空间不连续，如果要进行整体遍历，在某段空间的默认或首部时，必须要计算下一段或者前一段空间的位置，导致deque的效率比较底下。

总结：虽然deque结合了vector随机访问、方便尾插和list头插效率高等特点，但是为了满足这些优点却损失了太多的性能，导致整体中规中矩。

deque的原理图

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”的假象，落在了deque的迭代器身上。

deque的应用场景

deque在序列式容器中比较鸡肋，因为如果只是简单的存储元素，使用vector即可，如果对元素任意位置进行插入或者删除操作比较多，使用list即可，所以一般很少去使deque。而deque最大的应用，就是用其作为标准库中stack和queue的底层结构。

容器适配器

什么是适配器
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口，即就是底层把一个容器的数据结构和算法再加上自己本身要完成的功能接口封装在一起，变成一个新的“容器”，而我们将它称为容器适配器。
为什么将stack、queue和priority_queue称作为容器适配器
虽然stack、queue、priority_queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为每个容器在底层都有自己的实现方式，而stack、queue、priority_queue只是在底层将其他容器进行了封装，比如：

stack底层封装容器deque

queue底层也封装容器deque

而优先级队列底层封装了容器vector

为什么选择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不仅效率高，而且内存使用率高（而list节点伴随着new和delete操作）。

stack

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素。
3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作
   empty：判空操作
   back：获取尾部元素操作
   push_back：尾部插入元素操作
   pop_back：尾部删除元素操作
4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。
   

模拟实现

template<class T ,class container=deque<T>>
	class stack
	{
	public:
		void Push(const T& x)//入栈
		{
			_con.push_back(x);
		}
		void Pop()//出栈
		{
			_con.pop_back();
		}
		T& Top()//返回栈顶元素引用
		{
			return _con.back();
		}
		const T& Top()const
		{
			return _con.back();
		}
		bool Empty()//判空
		{
			return _con.empty();
		}
		size_t Size()//有效元素个数
		{
			return _con.size();
		}

	private:
		container _con;//底层容器
	};


	void TestStack()
	{
		//底层可以用不同的容器
		//Myadaper::stack<int, vector<int>> s;
		// Myadaper::stack<int, list<int>> s;
		//Myadaper::stack<int, deque<int>>
		stack<int,deque<int>> s;
		s.Push(1);
		s.Push(2);
		s.Push(3);
		s.Push(4);
		cout << s.Size() << endl;
		cout << s.Top() << endl;
		s.Pop();
		s.Pop();
		cout << s.Size() << endl;
		cout << s.Top() << endl;

		// FIFO first in last out
		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满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。
   

模拟实现

template<class T,class container=deque<T>>
	class queue
	{
	public:
		void Push(const T& x)
		{
			_con.push_back(x);
		}
		void Pop()
		{
			_con.pop_front();
		}
		T& Front()
		{
			return _con.front();
		}
		T& Back()
		{
			return  _con.back();
		}
		const T& Front()const
		{
			return _con.front();
		}
		const T& Back()const
		{
			return _con.back();
		}
		size_t Size()
		{
			return _con.size();
		}
		bool Empty()
		{
			return _con.empty();
		}
	private:
		container _con;
	};


	void TestQueue()
	{
		// 适配体现在第二个模板参数可以使用不同的容器，然后适配生成的queue效果是一样的。
		//queue<int, deque<int>> q;
		//queue<int, list<int>> q;
		queue<int,deque<int>> q;
		q.Push(1);
		q.Push(2);
		q.Push(3);
		q.Push(4);
		cout << q.Size() << endl;
		cout << q.Front() << endl;
		cout << q.Back() << endl;
		q.Pop();
		q.Pop();
		cout << q.Size() << endl;
		cout << q.Front() << endl;
		cout << q.Back() << endl;
		// FIFO first in first out
		while (!q.Empty())
		{
			cout << q.Front() << " ";
			q.Pop();
		}
		cout << endl;
	}

priority_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来自动完成此操作。

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

常用接口

和之前C语言写的堆一样，需要注意的是：
当堆中有数据插入时即push(),需要伴随着向上调整算法来维护当前堆属性；
当堆顶删除数据时即pop(),需要伴随着向下调整算法来维护堆属性，但是不能直接删除，会破坏堆结构，所以这个删除操作具体是先把首尾元素交换，再删除尾，然后才是向下调整算法。

模拟实现

//对于优先级队列来说，用户可能需要提供比较器规则来确定具体的优先级顺序

	// 默认给的小于的仿函数，实现的大堆，
	template<class T>
	struct less
	{
		bool operator()(const T& a, const T& b)
		{
			return a < b;
		}
	};
	// 默认给的大于的仿函数，实现的小堆，
	template<class T>
	struct greater
	{
		bool operator()(const T& a, const T& b)
		{
			return a > b;
		}
	};

	template<class T,class container=vector<int>,class compare=less<T>>//注意是三个模板参数，分别对应元素类型、底层容器、比较器规则（仿函数）
	class priority_queue
	{
	public:
		void AdJustDown(size_t root)
		{
			compare com;//对应的比较规则
			size_t parent = root;
			size_t child = 2 * parent + 1;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
					child++;
				//if (_con[child]>_con[parent])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}
		void AdJustUp(size_t child)
		{
			compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void Push(const T& x)
		{
			_con.push_back(x);
			AdJustUp(_con.size()-1);//插入数据后向上调整
		}
		void Pop()
		{
			swap(_con[0], _con[_con.size() - 1]);//删除堆顶数据，先交换首尾，在删除，接着向下调整
			_con.pop_back();
			AdJustDown(0);
		}
		const T& Top()const
		{
			return _con[0];
		}
		bool Empty()
		{
			return _con.empty();
		}
		size_t Size()
		{
			return _con.size();
		}

	private:
		container _con;
	};
	


	void test_priority_queue()
	{
		//priority_queue<int> pq; //默认大堆
		priority_queue<int, vector<int>, greater<int>> pq;//传入比较的仿函数
		pq.Push(10);
		pq.Push(2);
		pq.Push(30);
		pq.Push(21);
		pq.Push(5);

		while (!pq.Empty())
		{
			cout << pq.Top() << " ";
			pq.Pop();
		}
		cout << endl;

		//用于比较器规则仿函数类
		less<int> less_func;
		cout << less_func(1, 2) << endl;
		cout << less_func.operator()(1, 2) << endl;
		//仿函数，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。
		//类似于在C语言使用函数指针和回调函数来实现仿函数的，例如qsort排序中的自己定义的compare函数
	}