【C++ 学习】 priority_queue 优先队列的学习！！

1 queue****的介绍**

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

2. 优先级队列

priority_queue 底层是 大堆

默认 大的 优先级高

默认是用 vector 来适配的

1.1 怎么变成小堆呢 ？

• 仿函数的应用

less 小于 是 大堆 ；

greater 大于 是 小堆 ；

注意 ❗： 优先队列 这里得 大于 小于 跟其他得不一样，跟 sort 得就不一样， sort 从大到小排序用 greater ()

• sort 和 优先队列的区别（ 一个 greater 和 greater**()** ）

• 什么是仿函数呢？

通过重载 operator() 来实现这一特性。

仿函数就是普通的一个 类；

仿函数 / 函数对象

它的对象可以像函数一样使用

• struct 和 class 什么区别？
  class 有访问限定符（私有的要访问的话，就要用 友元，就会比较麻烦）， struct 则都是公有。

2. 优先队列模拟
   默认容器是 vector ，因为底层是 堆
   stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可

以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有

push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list。但是STL中对stack和

queue默认选择deque作为其底层容器，主要是因为：
stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。

2. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。

#pragma once
#include<list>
#include<deque>

using namespace std;

namespace luojie
{
	// 比较大小的仿函数
	template<class T>
	class less
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	class greater
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};


	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:

		// 向上调整
		void adjust_up(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

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

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

				//if (_con[child] > _con[parent])
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}

		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}

		const T& top()
		{
			return _con[0];
		}

	private:
		Container _con;
	};
}