stack queue模拟实现

适配器模式

stack,queue,priority_queue等再stl中没有划分再容器中，而是称为容器适配器，这些容器适配器对其他容器的接口进行包装，从而实现出适配器

stack模拟实现

使用适配器模式，实现栈，满足栈后进先出的规则

	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& val)
		{
			_con.push_back(val);
		}
		void pop()
		{
			_con.pop_back();
		}
		T& top()
		{
			return _con.back();
		}
		const T& top() const
		{
			return _con.back();
		}
		size_t size() const
		{
			return _con.size();
		}
		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};

queue模拟实现

使用适配器模式，实现队列，满足队列先进先出的规则

template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& val)
		{
			_con.push_back(val);
		}
		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() const
		{
			return _con.size();
		}
		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};

priority_queue

优先级队列本质是一个堆，默认情况下是一个大根堆，可以通过传递比较函数改成小根堆

template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
		void adjust_up(int child)
		{
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])
				if (Compare()(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
					break;
			}
		}

		void adjust_down(int parent)
		{
			int child = 2 * parent + 1;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				if (child + 1 < _con.size() && Compare()(_con[child], _con[child + 1]))
					child++;
				//if (_con[child] > _con[parent])
				if (Compare()(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
					break;
			}
		}

		void  push(const T& val)
		{
			_con.push_back(val);
			adjust_up(_con.size() - 1);
		}
		void pop()
		{
			swap(_con.back(), _con.front());
			_con.pop_back();
			adjust_down(0);
		}
		T& top()
		{
			return _con.front();
		}
		const T& top() const
		{
			return _con.front();
		}
		size_t size() const
		{
			return _con.size();
		}
		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};

deque

deque是stl中适配stack和queue的容器。
vector的优点：随机访问，缓存利用率高 缺点：除却尾插尾删其他部位插入删除效率低， 扩容有额外消耗
list的优点：插入删除效率高，按需申请结点 缺点：不支持随机访问，缓存利用率低
所以vector和list的优缺点互补，deque就是vector和list取长补短的产物，尽管还有些不足之处
deque有一个非常大的缺陷，就是它的遍历,下标访问时，每次都需要计算，这就导致遍历的效率较低了对比vector效率就比较低，同时deque在中间插入删除时，因为要挪动数据，所以效率比起list又有不足，而deque的尾插尾删头插头删效率很高，就很适合stack和queue

总结

总结一下，适配器本质是对代码复用的一种方法