C++ stack_queue详解

1. Stack

1.1 介绍

1. 在官方的文档介绍里，给我们之前介绍的vector、list定义为容器，而stack为容器适配器，即对容器进行了一层包装。
2. stack专门用于需要先进后出属性的情况中。
3. stack如果不指定底层的容器的话，默认的是deque容器，但vector、list容器也能适配。

1.2 使用

stack（）	构造空的栈
empty（）	判断栈是否为空
size（）	返回栈元素的个数
top（）	返回栈顶的元素
push （val_type& x）	将元素入栈
pop（）	将栈顶元素弹出

代码演示：

int main()
{
	stack<int> s;
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);

	while (!s.empty())
	{
		std::cout << s.top() << std::endl;
		s.pop();
	}

	return 0;
}

2. Queue

2.1 介绍

1. 和stack一样，queue是一种容器适配器。
2. queue专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
3. stack如果不指定底层的容器的话，默认的是deque容器，注意vector容器不能适配，因为vector容器不支持头插头删。

2.2 使用

queue（）	构造空的队列
empty（）	判断队列是否为空
size（）	返回队列元素的个数
front（）	返回队头的元素
back（）	返回队尾的元素
push （val_type& x）	将元素入队
pop（）	将栈顶元素出队

int main()
{

	queue<int> q;
	q.push(5);
	q.push(6);
	q.push(7);
	q.push(8);
	while (!q.empty())
	{
		std::cout << q.front() << std::endl;
		q.pop();
	}
	return 0;
}

3. priority_queue

3.1 介绍

1. priority_queue是优先队列，也是一种容器适配器。
2. priority_queue可以根据用户提供的compare，在常数时间内的获取最大/最小的元素。
3. priority_queue虽然叫优先级队列，但其底层是堆的结构，默认是大堆，用户可以提供compare将堆的结构变成大堆或小堆。
4. priority_queue 模板有 3 个参数，其中两个有默认的参数；第一个参数是存储对象的类型，第二个参数是存储元素的底层容器，第三个参数是函数对象（compare），它定义了一个用来决定元素顺序的断言。
5. 最后一个参数叫仿函数，虽然叫仿函数但是不是函数而是类

template <typename T, typename Container=std::vector<T>, typename Compare=std::less<T>> class priority_queue

3.2 使用

priority_queue（）	构造空的优先级队列
empty（）	判断是否为空
size（）	返回元素个数
top（）	返回最大（最小）元素
push（val_type& x）	插入元素x
pop（）	删除最大（最小）元素

// 默认情况下，创建的是大堆，其底层按照小于号比较
	std::vector<int> v{ 3,2,7,6,0,4,1,9,8,5 };
	std::priority_queue<int> q1;
	for (auto& e : v)
		q1.push(e);
	std::cout << q1.top() << std::endl;
	// 如果要创建小堆，将第三个模板参数换成greater比较方式
	std::priority_queue<int, std::vector<int>, std::greater<int> > q2(v.begin(), v.end());
	std::cout << q2.top() << std::endl;
	return 0;

4. 容器适配器

概念：容器适配器是一种数据结构，它提供了一种方便的方式来使用不同类型的容器，例如栈、队列和优先队列。容器适配器允许用户使用相同的接口来访问不同类型的容器，而不需要了解其内部实现细节。这样可以方便地在不同的场景中使用不同类型的容器，而不需要改变代码。常见的容器适配器包括stack、queue和priority_queue。

容器适配器包装容器类，封装容器类的接口，再提供接口给用户使用。

代码演示：

template<class T,class Con = std::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();
		}
		const T& top() const
		{
			return _c.back();
		}
		size_t size() const
		{
			return _c.size();
		}
		bool empty() const
		{
			return _c.empty();
		}
	private:
		Con _c;
	};