---

优先级队列的使用

优先级队列本质是就是完全二叉树,是个堆.我们可以用优先级队列来取出一段序列中的前N个最大值.

	priority_queue<int> pq;

第一个模板参数是数据类型,第二个是容器适配器,通俗点来讲就是这个堆用什么容器来实现,第三个就是排序方式(用仿函数来实现),这个能决定这个堆是大堆还是小堆.

大堆

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int main()
{priority_queue<int> pq;pq.push(1);pq.push(100);pq.push(66);pq.push(9);pq.push(20);pq.push(2);pq.push(8);while (!pq.empty()){cout << pq.top() << " ";pq.pop();}cout << endl;return 0;
}

将一些无序的数据存到优先级队列里面,它会给数据排成一个堆,我们可以依次取出数据,然后删除.
默认是大堆

小堆

	priority_queue<int, vector<int>, greater<int>> pq;	

只需要在定义时声明就行.

注意

greater是小堆,less是大堆

优先级队列的模拟实现

这里我们先实现一个大堆

	template<class T, class Container = vector<T>>class priority_queue{private:Container _con;}

因为二叉树push数据的时候经常要交换位置,我们经常要访问它的父亲节点和子节点,所以默认的容器适配器是vector,你也可以改成deque(双向队列)

push

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

堆的插入是尾插,然后再把这个数据向上调整

	void adjust_up(size_t child){size_t parent = (child - 1) / 2;while (child > 0){if(_con[child] > _con[parent]){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}

比较逻辑:找到父亲节点,将父亲节点和子节点比较,如果子节点>父亲节点,交换,然后更新节点.
注意:父亲节点=(子节点-1)/2

pop

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

在删除节点的时候,为了效率.我们把第一个节点和最后一个节点交换,删除最后一个节点(此时堆的最大值).再把第一个节点(原来的最后一个节点)向下调整.

	void adjust_down(size_t parent){size_t child = parent * 2 + 1;if (child + 1 < _con.size() && _con[child] < _con[child + 1])child++;while (child < _con.size()){if (_con[parent]<_con[child]){swap(_con[parent], _con[child]);parent = child;child = parent * 2 + 1;}else{break;}}}

向下调整的过程中,如果满足父亲节点<子节点,二者交换.直到父亲节点>子节点或者子节点越界.
注意在向下调整的过程中始终选择大的孩子进行比较,这是为了满足大堆的性质,父亲节点一定>=子节点.
左孩子=父亲节点2+1,右孩子=父亲节点2+2

size

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

size和empty都可以复用vector里面的函数,但是我们要在前面包上vector的头文件

empty

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

top

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

堆的头就是数组里面的第一个数据

仿函数

我们如果要改变大小堆的话,其实只需要把小于改成大于,大于改成小于就行.但如果每次都这么改,会大大增加我们的工作量,在c语言中,我们可以使用函数指针来解决.在c++中,祖师爷设计了一种更方便的做法,也就是仿函数.

仿函数是什么

仿函数本质上是一个类,这个类能模拟函数的行为.实现内置类型或者自定义类型的比较

template<class T>
struct Less
{bool operator()(const T& x, const T& y){return x < y;}
};
int main()
{Less<int> func;cout << func(1, 2) << endl;cout << func.operator()(1, 2) << endl;return 0;
}

func(1,2)看起来是不是跟我们平时调用函数一样,传两个参数.实际上,Less仿函数里对()进行操作符重载,让我们可以比较两个数的大小

这个做法衍生到堆上面,我们可以传两个仿函数,一个大于,一个小于.然后在堆里面实例化出对象.

	template<class T>struct greater{bool operator()(const T& t1,const T& t2){return t1 > t2;}};template<class T>struct less{bool operator()(const T& t1, const T& t2){return t1 < t2;}};

push

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& val)
{_con.push_back(val);adjust_up(_con.size() - 1);
}

pop

		void adjust_down(size_t parent){Compare com;size_t child = parent * 2 + 1;if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))child++;while (child < _con.size()){//if (_con[parent] < _con[sun])if (com(_con[parent], _con[child])){swap(_con[parent], _con[child]);parent = child;child = parent * 2 + 1;}else{break;}}}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();adjust_down(0);}

仿函数结合优先级队列的优势

priority_queue<int> pq;
priority_queue<int,vector<int>,greater<int>> pq;

首先我们可以自己控制大堆/小堆.
其次在面对商品等复杂类型中,需要我们根据价格,评价,销量等等进行排序时.单靠商品类里面的一个操作符重载小于或者大于是不够的,我们可以写多个仿函数,争对价格,评价等进行比较.