C++的stack和queue+优先队列

什么是容器适配器

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

底层逻辑

stack和queue都是容器适配器,底层都是通过去适配双端队列deque去实现的,STL中没有把stack和queue划分在容器中,而是放在容器适配器,stack和queue默认使用deque.


那可不可以用vector去适配呢?
这也是可以的,只要是他们的所有接口,在这个容器中包含就可以进行适配,那么为什么底层默认会选择使用deque去进行适配呢?
deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。
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的优点，而完美的避开了其缺陷。

优先队列

优先队列本质上就是topk问题,那么优先队列是怎么实现的呢？
优先队列的底层物理结构是数组,其中模板参数Compare是控制优先队列是大堆还是小堆,
优先队列默认是大堆–缺省参数就是less,如果要给大堆就是greater
这两个模板参数的底层实现:

//仿函数/函数对象
//重载了括号,让类可以向函数一样被调用
template<class T>
class Less
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

template<class T>
class Greater
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x > y;
	}
};

优先队列的模拟实现

//优先队列,其实就是topk问题,底层结构就是堆,所以我们用数组---vector来存取数据
	template<class T, class Container = vector<T>, class Compare = less<T>>//默认是大堆,less对应的就是大堆
	//greater<T>对应的是小堆 通过传Compare来控制大堆还是小堆,默认不传是大堆
	//仿函数控制实现大小堆
	class priority_queue
	{
	private:
		void AdjustDown(size_t parent)
		{
			Compare com;

			size_t chidren = parent * 2 + 1;
			while (chidren < _con.size())
			{
				if (chidren + 1 < _con.size() && com( _con[chidren], _con[chidren + 1]))
				{
					chidren += 1;
				}
				//if (_con[parent] < _con[chidren])
				if (com(_con[parent], _con[chidren]))
				{
					swap(_con[parent], _con[chidren]);
					parent = chidren;
					chidren = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void AdjustUp(int chidren)
		{
			Compare com;

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

	public:
		priority_queue()
		{

		}

		template<class InputInterator>
		priority_queue(InputInterator first, InputInterator last)
		{
			//插入数据
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}

			//建堆
			//从最后一个非叶子节点开始建堆-----关键
			for (int i = (_con.size()-1-1) / 2; i >= 0; i--)
			{
				AdjustDown(i);
			}
		}

		void pop()//删除的是第一个元素
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			AdjustDown(0);
		}

		void push(const T& x)
		{
			//_con[_con.size()] = x;
			_con.push_back(x);
			AdjustUp(_con.size() - 1);
		}

		T& top()
		{
			return _con[0];
		}

		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};

stack和queue的模拟实现

#pragma once

//适配器模拟实现
namespace sw
{	
	//数组栈与链式栈之间秒切换---------适配器
	template<class T, class Container = deque<T>>//模板参数不仅可以是int,double等内置类型也可以是容器,同时也可以给缺省值
	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;
	};

	void test_stack()
	{
		cout << "stack" << endl;

		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;
		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;
		stack<int> st3;
		st3.push(1);
		st3.push(2);
		st3.push(3);
		st3.push(4);
		while (!st3.empty())
		{
			cout << st3.top() << " ";
			st3.pop();
		}
		cout << endl;
	}
}

#pragma once

namespace sw
{
	//适配器
	template<class T, class Container = deque<T>>//模板参数不仅可以是int,double等内置类型也可以是容器,同时也可以给缺省值
	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();
		}

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

		bool empty()
		{
			return _con.empty();
		}


	private:
		Container _con;
	};

	void test_queue()
	{
		cout << "queue" << endl;
		queue<int, deque<int>> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);
		while (!q1.empty())
		{
			cout << q1.front() << " ";
			q1.pop();
		}
		cout << endl;
		queue<int, list<int>> q2;
		q2.push(1);
		q2.push(2);
		q2.push(3);
		q2.push(4);
		while (!q2.empty())
		{
			cout << q2.front() << " ";
			q2.pop();
		}
		cout << endl;

	}
}