STL篇：堆与优先级队列

一、（大）堆

1、插入
大堆插入数据，向上调整

2、删top
错误方式：挪动删除（效率低下且父子兄弟关系全乱了）
正确方式：交换头尾，pop掉尾，头向下调整（哪个儿子大，调哪个）

3、建堆
向上调整建大堆：从头开始，模拟插入数据的过程（时间复杂度：nlogn）
向下调整建大堆：从倒数第一个非叶子节点开始调整（大的向上调整，小的向下调整）（时间复杂度：logn）
向下调整建堆条件是左右子树均是大/小堆（所以从倒数第一个非叶子节点开始调整），这种方法的效率比向上调整建堆效率高

4、排升序：
正确：建大堆，交换，向下调整（跟删除数据一样的思路）
错误：建小堆，如果挪动删除，剩下的看作堆，选次小的，但是关系乱了，得重新建堆
同理：排降序建小堆

5、topk问题：找最大的前k个数，要（将前k个数）建小堆，交换头尾，再将头向下调整

ps：若以上讨论为小堆，则将大于改成小于即可。

二、优先级队列
1、优先级队列底层是二叉树——堆
2、默认大堆——less，仿函数实现小堆——greater

3、模拟实现：

//PriorityQueue.h
#pragma once
#include<vector>
#include<iostream>
using namespace std;

//仿函数/函数对象（重载了operator（））：这个类对象可以向函数一样使用（替代C语言中的函数指针）
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;
	}
};

namespace star
{
	template<class T, class Container = vector<T>, class Compare = Less<T>>//函数模板要传对象，类模板要传类型（此处传类型，无需加()）
	class PriorityQueue
	{
	private:
		void adjustup(int child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjustdown(int parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}
				if (com( _con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
	public:
		PriorityQueue()
		{}

		template<class InputIterator>
		PriorityQueue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				first++;
			}
			int parent = (_con.size() - 1 - 1) / 2;
			for (int i = parent; i >= 0; i--)
			{
				void adjustdown(i);
			}
		}

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

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


		void push(const T& val)
		{
			_con.push_back(val);
			int child = _con.size()-1;
			adjustup(child);
		}

		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};
}