stack和queue的使用

stack的介绍及使用
1.stack是一种容器适配器，专门用在具有先进后出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作
2.stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部（栈顶）被压入和弹出。
3.stack的底层容器可以使任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
empty：判空操作
back：获取尾部元素操作 pop
push_back：尾部插入元素操作 push
pop_back:尾部删除元素操作
4.标准容器vector、list、deque均符合这些要求，默认情况下，如果没有为stack指定特定的底层容器，默认用deque
相当于vector：增容代价小
相当于list：可以减少内存碎片
stack的使用
stack()：构造空的栈
empty()：检测stack是否为空
size()：返回stack中元素的个数
top()：返回栈顶元素的引用
push()：将元素val压入stack
2.queue的介绍和使用
queue的介绍：
1.队列是一种容器适配器，专门用于在FIFO上下文（先进先出）中操作，其中从容器一端插入元素，另一端提取元素
2.队列作为容器适配器实现，容器适配器即将特定容器封装作为其底层容器类，queue提供一组特定的成员函数 来访问其元素。元素从队尾入队列，从队头出队列
3.底层容器可以是标准容器类模版之一，也可以是其他专门设计的容器类。该底层容器 应支持：
empty：检测队列是否为空
size:返回队列中有效元素的个数
front：返回队头元素的引用
back:返回队尾元素的引用
pus h_back:在队列尾部入队列
pop_front:在队列头部出队列
4.标准容器类deque和list满足这些要求，默认其情况下，如果没有deque实例化指定容器类，则使用标准容器deque
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的使用
优先级队列默认使勇气用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue
容器适配器
适配器是一种设计模式，它是被人反复使用的，多数人知晓的，经过分类编目的，代码设计经验的总结。
为什么将stack，queue，priority_queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为每个容器在底层都有自己的实现方式，而stack、queue、priority_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不仅效率高，而且内存率高

#include<vector>
#include<functional>
#include<iostream>
#include<stdlib.h>
using namespace std;
//namespace zhao
//{
//	template<class T, class Con = deque<T>>
//	class stack
//	{
//	public:
//		stack()
//		{
//		}
//		void push(const T& x)
//		{
//			_c.push_back(x);
//		}
//		void pop()
//		{
//			_c.pop_back();
//		}
//		T& top()
//		{
//			return _c.back();
//		}
//		size_t size() const
//		{
//			return _c.size();
//		}
//		bool empty()const
//		{
//			return _c.empty();
//		}
//	private:
//		Con _c;
//	};
//}
//void TestStack()
//{
//	/*zhao::stack<int, vector<int>> s;
//	zhao::stack<int, list<int>> s;
//	zhao::stack<int,deque<int>>
//	}*/
//	zhao::stack<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();
//}

//queue的模拟实现
#include<deque>
namespace lin
{
	template<class T,class Con=deque<T>>
	class queue
	{
	public:
		queue()
		{}
		void push(const T& x) 
		{
			_c.push_back(x);
		}
		void pop()
		{
			_c.pop_front();
		}
		T& back() 
		{
			return _c.back();//返回最后一个元素的引用
		}
		T& front() 
		{
			return _c.front();
		}
		/*const T& front() const
		{
			return _c.front();
		}*/
		size_t size()const
		{
			return _c.size();
		}
		bool empty() const
		{
			return _c.empty();
		}
	private:
		Con _c;
	};
}
void TestQueue()

{
	//lin::queue<int, deque<int>> q;
	lin::queue<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;
}
//priority_queue的模拟实现
namespace fen
{
	template<class T,class Sequeue=vector<T>,class Compare=less<T>>
	class priority_queue
	{
	public:
		priority_queue() :c()
		{}
		template <class IputIterator>
		priority_queue(InputIterator first, InputIterator last)
			: c(first, last)
		{
			make_heap(c.begin(), c.end(), comp);
		}
		bool empty()const
		{
			return c.empty();
		}
		size_t size() const
		{
			return c.size();
		}
		T& top() const
		{
			return c.front();
		}
		void push(const T& x)
		{
			c.push_back(x);
			push_heap(c.begin(), c.end(), comp);
		}
		void pop()
		{
			pop_heap(c.begin(), c.end(), comp);
			c.pop_back();
		}
	private:
		Sequeue c;
		Compare comp;
	};
}

int main()
{
	TestQueue();
	system("pause");
	return 0;
}