优先级队列prority_queue

优先级队列：
parent:
left child: 2 * parent + 1 right child: 2 * parent + 2
child:
parent:(child - 1) / 2
插入时先尾插

list不支持随机访问， 不能作为优先级队列的底层容器
优先级队列的默认容器： vector—>随机访问的效率高于双端队列
比较规则---->仿函数类
仿函数类----> 必须重载 返回值operator（）（参数列表）
数据的比较-----> 大于：支持 >，小于： <
1.内置类型：本身支持大于小于比较
2.自定义类型： 重载>, < 运算符

附上实现优先级队列的代码：

//仿函数类：功能类似于函数的类
//必须重载括号（）运算符
template<class T>
struct Less
{
	bool operator()(const T& val1, const T& val2)
	{
		return val1 < val2;
	}
};

template<class T>
struct Greater
{
	bool operator()(const T& val1, const T& val2)
	{
		return val1 > val2;
	}
};


//默认是大堆
template<class T, class Container = vector<T>, class Compare = less<T>>
class Priority_queue
{
public:
	//向上调整
	void shiftUp(int child)
	{
		int parent = (child - 1) / 2;
		while (child > 0)
		{
			if (_com(_c[parent], _c[child]))
			//if (_c[parent] < _c[child])
			{
				swap(_c[parent], _c[child]);

				child = parent;
				parent = (child - 1) / 2;

			}
			else{
				break;
			}
		}
	}

	void push(const T& val)
	{
		_c.push_back(val);
		shiftUp(_c.size() - 1);
	}

	//删除堆顶的元素，把堆顶的元素和最后一个元素进行交换然后向下调整使之成为堆
	void pop()
	{
		//1.首尾元素交换
		swap(_c[0], _c[_c.size() - 1]);
		//2.尾删
		_c.pop_back();
		//2.向下调整
		shiftDown(0);
	}

	T& top()
	{
		return _c.front();
	}

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

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

	//向下调整
	void shiftDown(int parent)
	{
		int child = parent * 2 + 1;
		while (child < _c.size())
		{
			//1.先找出左右孩子中的最大值，注意存在没有右孩子的情况
			if (child + 1 < _c.size() && _com(_c[child], _c[child + 1]))
			//if (child + 1 < _c.size() && _c[child] < _c[child + 1])
			{
				child = child + 1;
			}
			//2.和父节点进行比较然后完成交换，进一步迭代更新父亲孩子的位置
			if (_com(_c[parent], _c[child]))
			//if (_c[parent] < _c[child])
			{
				swap(_c[parent], _c[child]);
				parent = child;
				child = 2 * parent + 1;
			}
			else{
				break;
			}
		}
	}


private:
	Container _c;
	Compare _com;
};

仿函数类：
使用方式类似与函数调用：
1.完整形式：仿函数对象。operator（）（参数列表）
2.常用形式（简写形式）：仿函数对象（参数列表）