STL—stack、queue以及priority_queue（优先级队列）的模拟实现。

一 .stack的模拟实现。

(一)stack介绍：

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，只能从容器的一端进行元素的插入与提取操作。
2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3. stack底层结构需要满足的接口：
   empty：判空操作
   back：获取尾部元素操作
   push_back：尾部插入元素操作
   pop_back：尾部删除元素操作
4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。
   
   stack的使用：

•   stack() 构造空的栈
  

•   empty() 检测stack是否为空
  

•   size() 返回stack中元素的个数
  

•   top() 返回栈顶元素的引用
  

•   push() 将元素压入stack中
  

•   pop() 将stack中尾部的元素弹出
  

(二)stack的模拟实现：

利用deque作为底层结构实现：

#include<iostream>
#include<deque>
namespace Ice
{
	template<typename T, class Con = deque<T>>
	class Stack
	{
	public:
		Stack()
		{
		}
		void Push(const T& x)
		{
			_st.push_back(x);
		}
		void Pop()
		{
			_st.pop_back();
		}

		T& Top()
		{
			return _st.back();
		}

		size_t Size()
		{
			return _st.size();
		}

		bool Empty()
		{
			return _st.empty();
		}
	private:
		Con _st;
	};
}

int main()
{
	Ice::Stack<int> st;

	st.Push(1);
	st.Push(2);
	st.Push(3);

	st.Pop();

	cout << st.Top() << endl;

	cout << st.Size() << endl;
	cout << st.Empty() << endl;

	return 0;
}

也可以以list，vector作为底层进行模拟实现。。。

二.queue的模拟实现。

(一)queue的介绍：

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
2. queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。底层容器应至少支持以下操作:
   empty：检测队列是否为空
   size：返回队列中有效元素的个数
   front：返回队头元素的引用
   back：返回队尾元素的引用
   push_back：在队列尾部入队列
   pop_front：在队列头部出队列
3. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

queue的使用：

•   queue() 构造空的队列
  

•   empty() 检测队列是否为空，是返回true，否则返回false
  

•   size() 返回队列中有效元素的个数
  

•   front() 返回队头元素的引用
  

•   back() 返回队尾元素的引用
  

•   push() 在队尾将元素val入队列
  

•   pop() 将队头元素出队列
  

(二)queue的模拟实现：

以deque为底层模型：

namespace Ice
{
	template<typename T,class Con = deque<T>>
	class Queue
	{
	public:
		Queue()
		{}
		
		void Push(const T& x)
		{
			_qu.push_back(x);
		}
		void Pop()
		{
			_qu.pop_front();
		}

		T& Front()
		{
			return _qu.front();
		}
		T& Back()
		{
			return _qu.back();
		}

		size_t Size()
		{
			return _qu.size();
		}
		bool Empty()
		{
			return _qu.empty();
		}

	private:
		Con _qu;
	};
}
int main()
{
	Ice::Queue<int> qu;

	qu.Push(1);
	qu.Push(2);
	qu.Push(3);
	qu.Pop();

	cout << qu.Front() << endl;//2
	cout << qu.Back() << endl;//3
	cout << qu.Size() << endl;//2
	cout << qu.Empty() << endl;//0
	return 0;

}

也可以以list作为底层进行模拟实现。。。

vector没有头部删除接口，因此无法作为queue的底层结构。

注意：

1. stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以；
2. queue是先进先出的特殊线性数据结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

• stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。
• 在stack中元素增长时，deque比vector的效率高；queue中的元素增长时，deque不仅效率高，而且内存使用率高。

三.priority_queue的介绍。

(一)priority_queue简介：

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2. 优先队列被视为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
3. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

• empty()：检测容器是否为空
• size()：返回容器中有效元素个数
• front()：返回容器中第一个元素的引用
• push_back()：在容器尾部插入元素
• pop_back()：删除容器尾部元素

4. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
5. 需要支持随机访问迭代器，始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

(二)priority_queue 的接口使用：

•   priority_queue()/priority_queue(first,last) 构造一个空的优先级队列
  

•   empty()检测优先级队列是否为空，是返回true，否则返回false
  

•   top() 返回优先级队列中最大(最小元素)，即堆顶元素
  

•   push(x) 在优先级队列中插入元素x
  

•   pop()  删除对内最大的元素
  

int main()
{
	vector<int> vt{ 1,4,6,3,0,2,5 };

	priority_queue<int> p1;

	for (auto& e : vt)
	{
		p1.push(e);
	}
	cout << p1.top() << endl;

	//调整为小堆将第三个参数换一下 greater 方法
	priority_queue<int, vector<int>, greater<int>> q2(vt.begin(), vt.end());
	cout << q2.top() << endl;
	q2.pop();
	cout << q2.top() << endl;
	return 0;
}

(三)priority_queue的模拟实现：

#include<iostream>
#include<vector>
#include<functional>  //算法头文件
namespace Ice
{
	template<class T, class Con = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
		priority_queue() :_c()
		{}

		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			: _c(first, last)
		{
			make_heap(_c.begin(), _c.end(), Com);
		}
		bool empty()  
		{
			return _c.empty();
		}
		size_t size()
		{
			return _c.size();
		}
		T& top()
		{
			return _c.front();
		}
		void push(const T& x)
		{
			_c.push_back(x);
			push_heap(_c.begin(), _c.end(), Com);
		}
		void pop()
		{
			pop_heap(_c.begin(), _c.end(), Com);
			c.pop_back();
		}

	private:
		Con _c;
		Compare Com;
	};
}


int main()
{
	vector<int> vt{ 3, 2, 5, 4, 6, 7 };
	Ice::priority_queue<int> q1;
	for (int i = 0; i < vt.size();++i)
		q1.push(vt[i]);

	cout << q1.top() << endl;  // 7

	return 0;
}