STL queue，stack,priority_queue的模拟实现

1,stack的模拟实现

1.stack是一种容器适配器.
2容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：empty，back，push_back，pop_back
4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

namespace yyy
{
	template <class T, class Container = deque<T>>   //stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，如果不传入，默认是deque。
	class stack {
	public:
		void push_back(const T& t)
		{
			st.push_back(t);

		}
		void pop()
		{
			st.pop_back();
		}
		T& top()
		{
			return st.back();
		}
		const T& top()const
		{
			return st.back();
		}
		bool empty()const

		{
			return st.empty();

		}
		size_t size() const

		{
			return st.size();
		}
	private:
		Container st;  
	};
}

2,queue的模拟实现

1. 队列是一种容器适配器，底层容器可以是标准容器类。该底层容器应至少支持以下操作:empty，size，front，back，push_back，pop_front。
   2，标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标,准容器deque。

#pragma once
#include<deque>
namespace yyy
{
	template <class T, class Container = deque<T>>
	class queue {
	public:
		void push(const T& t)
		{
			qu.push_back(t);

		}
		void pop()
		{
			qu.pop_front();
		}
		T& back()
		{
			return qu.back();
		}
		T& front()
		{
			return qu.front();
		}

		bool empty()const

		{
			return qu.empty();

		}
		size_t size() const

		{
			return qu.size();
		}
	private:
		Container qu;
	};
}

3, priority_queue的模拟实现

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

堆的操作 堆的各种操作

#pragma once
#include<vector>
namespace yyy
{//less大堆greater小堆
	template <class T,class Coutainer=vector<T>,class Compare=std::less<T>>   //第二个参数是默认底层容器是vector，第三个参数，Compare是一个进行比较的仿函数，默认是大的优先级高
	class priority_queue
	{
	public:
		priority_queue()
		{

		}
		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				t.push_back(*first);
				first++;
			}
			//向下调整建队
			for (int i = (t.size() - 1 - 1) / 2; i >= 0; i--)
			{
				adjust_down(i);
			}
		}

		void adjust_up(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if(com(t[parent],t[child]))
				{
					std::swap(t[child], t[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
				
	   }
		}
		void adjust_down(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < t.size())
			{
				if ((child + 1 < t.size()) && com(t[child], t[child + 1]))
				{
					child++;
				}
				if (com(t[parent], t[child]))
				{
					std::swap(t[parent], t[child]);
						parent = child;
						child = parent * 2 + 1;
				}
				else {
					break;
				}

			}

		}
		void push(const T&x)
		{
			t.push_back(x);
			adjust_up(t.size()-1);

			
		}
		void pop()
		{
			std::swap(t[0], t[t.size() - 1]);
			t.pop_back();
			adjust_down(0);
		}
		const T& top()
		{
			return t[0];
		}
		bool empty() const
		{
			return t.empty();
		}
		size_t size() const
		{
			return t.size();
		}

	private:Coutainer t;
	};
}

4，为什么deque很适合做stack和queue的默认适配容器？

因为deque可以任意位置插入删除，可以随机访问，是list和vector的结合体，对于头尾的插入删除，queue很适合，对于中间插入删除多用list,对于随机访问多用vector。但是它也有缺陷，1，operator[]计算稍显复杂，大量使用，性能下降，2,中间插入删除效率不高，3,底层角度迭代器会很复杂。

5，仿函数less greater

仿函数是一个函数对象，其实是一个类，重载了operator()

//仿函数/函数对象/类，重载operator（）
//类对象可以像函数一样使用
namespace  yy
{
	template<class T>
	class less
	{
	public:
		bool operator()(const T& l, const T& r)
		{
			return l < r;
		}
	};
	template<class T>
	class greater
	{
	public:
		bool operator()(const T& l, const T& r)
		{
			return l < r;
		}
	};
}
void test1()
{	
yy::less<int> fun;
cout << fun(1, 2) << endl;
//本质上是cout<<fun.operator()(1,2)<<endl;

}

}