优先级队列

优先级队列 priority_queue

是一个容器适配器。
不符合先进先出。push时随意，pop和top取优先级最高的。
优先级由大小决定，默认大的优先级高，也可以通过仿函数来控制。

基本接口使用

通过示例：向priority_queue pq内push多个无规律的数字，取其top打印，再pop，直至其中没有数据。
会发现结构是一个大堆，默认的top为最大值。
每次出队都会将堆的结构调整，将右下方的最小值与最顶上的交换，再进行向下调整算法。

如果是想要改变优先级
priority_queue<int, vector<int>, greater<int>> pq
注意第三个模版参数是传递的类型，与改变sort的顺序不同，后者是传入的对象。

class Solution {public:int findKthLargest(vector<int>& nums, int k) {priority_queue<int> pq(nums.begin(), nums.end());while(--k){pq.pop();}return pq.top();}
};

While(k- -)执行k次，while(- - k)执行k - 1次。

优化：利用优先级队列建立含有k个数据的小堆，再将剩下数据与小堆堆顶比较，比小堆top大，就pop小堆，再将其存放进去。

int findKthLargest(vector<int>& nums, int k) {priority_queue<int, vector<int>, greater<int>> kMinHeap;for(size_t i = 0; i < k; i++){kMinHeap.push(nums[i]);} for(size_t i = k; i < nums.size(); i++){if(kMinHeap.top() < nums[i]){kMinHeap.pop();kMinHeap.push(nums[i]);}}return kMinHeap.top();}

模拟实现

仿函数——利用自定义类型中的()运算符重载，模拟出函数。
当然不只是用来比大小。比如自定义日期类，向优先级队列中插入不同日期类对象的地址，然后要选出最大的地址。如果直接取出堆顶，只能得到最大的对象地址，但如果利用仿函数重载()，实现两个日期类对象的地址比较时，返回大的日期。

#include <vector>
namespace yfy {template<class T>
class Less
{public:bool operator()(const T& a, const T& b){return a < b;}
};template<class T>
class Greater
{public:bool operator()(const T& a, const T& b){return a > b;}
};template<class T, class Container = vector<T>, class Compare = Less<T>>
class priority_queue
{public:priority_queue(){}template <class InputIterator>priority_queue(InputIterator first, InputIterator last){//插入数据while(first != last){_con.push_back(*first);first++;}//建堆for(size_t i = (_con.size() - 1 - 1) / 2; i >= 0; i--){AdjustDown(i);}}Compare com;void AdjustUp(size_t child){size_t parent = (child - 1) / 2;while(child > 0){if(com(_con[parent], _con[child])){swap(_con[parent], _con[child]);child = parent;parent = (child - 1) / 2;}else{break;}}}void AdjustDown(size_t parent){size_t l_child = parent * 2 + 1;while(l_child < _con.size()){if(l_child + 1 < _con.size() && com(_con[l_child], _con[l_child + 1])){l_child++;}if(com(_con[parent], _con[l_child])){swap(_con[parent], _con[l_child]);parent = l_child;l_child = parent * 2 + 1;}else{break;}}}void push(const T& val){_con.push_back(val);AdjustUp(_con.size() - 1);}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();AdjustDown(0);}const T& top(){return _con.front();}bool empty(){return _con.empty();}private:Container _con;
};void test1()
{priority_queue<int, vector<int>, Greater<int>> pq;pq.push(1);pq.push(0);pq.push(3);pq.push(100);while(!pq.empty()){cout << pq.top() << endl;pq.pop();}
}}