STL--priority_queue

一、priority_queue介绍

priority_queue中文名叫优先权队列

优先级队列是一种容器适配器，根据一些排序标准，专门设计使其第一个元素始终是它包含的最大元素

类似于堆，可以随时插入元素，并且只能检索最大堆元素（优先级队列顶部的那个）

template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;
//其中的less是一个仿函数，仿函数的特点就是会重载运算符

二、priority_queue接口

函数名称	功能说明
empty	判断容器是否为空
size	返回容器容量大小
top	返回优先级队列顶部数据
push	从优先级队列顶部插入元素
pop	删除优先级队列顶部元素

三、priority_queue模拟实现

优先级队列的本质上是一个堆，而堆的本质上是一个数组。因此在建堆运算的时候，就可以通过更改对比方法，来实现大小堆。为了实现封装并且更容易的选择大小堆，优先级队列采用了仿函数的方法

原本的大小堆转换，是通过改变向上调整和向下调整中父子节点的大小关系实现的

在向上调整中：如果父节点小于子节点就交换，则是大堆

在向下调整中：如果父节点小于子节点就交换，则是大堆

在仿函数中重载了()运算符，从而实现了大小的比较。传入的参数模板可以选择less大堆或者greater小堆

注意：对于自定义类型，由于编译器无法判断其大小，需要重写用于比较的仿函数

#pragma once
#include<iostream>
#include<vector>
using std::cout;
using std::endl;

namespace my_priority_queue
{
	template<class T>
	struct less//默认是小于
    //不论是向上调整还是向下调整，比较过后都会进行swap
    //因此x<y，swap之后，x会在y的后面，也就是小的放在后面，因此是大堆
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	struct greater//对应小堆
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};



	//其中的less就被称为仿函数，也就是通过模板实现函数功能，从而区分大小堆
	template<class T,class Container=std::vector<T>,class Compare=less<T>>
	class priority_queue
	{
	public:
		void adjust_up(size_t child)//大堆
		{

			int parent = (child - 1) / 2;
			while (child>0)
			{
				Compare com;//仿函数
				if (com(_con[parent], _con[child]))
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(size_t parent)//大堆
		{
			int child = parent * 2 + 1;
			while (child<_con.size())
			{
				Compare com;
				if (child + 1 < _con.size() 
					&& com(_con[child] , _con[child+1]))
				{
					++child;
				}
				
				if (com(_con[parent] , _con[child]))
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}

		}
		void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}
		void pop()
		{
			std::swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}
		const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};


	void test_1()
	{
		cout << "less建大堆" << endl;

		priority_queue<int,std::vector<int>,less<int>> p1;
		p1.push(1);
		p1.push(19);
		p1.push(5);
		p1.push(2);
		p1.push(6);
		p1.push(3);
		while (!p1.empty())
		{
			cout << p1.top() << " ";
			p1.pop();
		}
		cout << endl;
		p1.push(1);
		p1.push(19);
		p1.push(5);
		p1.push(2);
		p1.push(6);
		p1.push(3);
		p1.pop();
		p1.pop();
		while (!p1.empty())
		{
			cout << p1.top() << " ";
			p1.pop();
		}
		cout << endl;


		cout << "greater建小堆" << endl;
		priority_queue<int, std::vector<int>, greater<int>> p2;
		p2.push(1);
		p2.push(19);
		p2.push(5);
		p2.push(2);
		p2.push(6);
		p2.push(3);
		while (!p2.empty())
		{
			cout << p2.top() << " ";
			p2.pop();
		}
		cout << endl;
		p2.push(1);
		p2.push(19);
		p2.push(5);
		p2.push(2);
		p2.push(6);
		p2.push(3);
		p2.pop();
		p2.pop();
		while (!p2.empty())
		{
			cout << p2.top() << " ";
			p2.pop();
		}
		cout << endl;
	}
}