算法笔记 C++ 优先级队列

API

定义

定义：priority_queue<Type, Container, Functional>

• Type 数据类型
• Container 容器类型

（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector）

• Functional 比较的方式

当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是less，大顶堆

printf("\n------------- 基本类型 ------------\n");
priority_queue<int,vector<int>,greater<int>> gp; //小顶堆
priority_queue<int,vector<int>,less<int>> lp; //大顶堆
printf("\n------------- pair类型 ------------\n");
priority_queue<pair<int,int>,vector<pair<int,int>>,less<pair<int,int>>> pql; //小顶堆
priority_queue<pair<int,int>,vector<pair<int,int>>,less<pair<int,int>>> pql; //大顶堆
printf("\n------------- 结构体类型 ------------\n");
priority_queue<Node,vector<Node>> gps; //小顶堆-重载小于号
priority_queue<Node,vector<Node>,cmps> lps; //大顶堆-重写仿函数

优先级的设置

基础类型优先级设置

less<int> 大顶堆
greater<int> 小顶堆

pair类型优先级设置

less<pair<int,int>> 大顶堆
greater<pair<int,int> 小顶堆

结构体类型优先级设置

重载小于号

不可重载大于号，会编译错误

struct Node {
	int d;
	int i;
	Node() {}
	Node(int _d,int _i):d(_d),i(_i) {}
	// 结构体类型优先级设置---方法一：重载小于号
	friend bool operator <(Node n1,Node n2) {
		return n1.d<n2.d;
		// 小于是大顶堆，元素从大到小
		// 大于是小顶堆，元素从小到大
	}
};

重写仿函数

struct cmps {
	bool operator()(Node n1,Node n2) {
		return n1.d>n2.d;
	}
};

基本操作

top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插入元素到队尾 (并排序)
emplace 原地构造一个元素并插入队列
pop 弹出队头元素
swap 交换内容

使用

#include <iostream>
#include <queue>
using namespace std;
struct Node {
	int d;
	int i;
	Node() {}
	Node(int _d,int _i):d(_d),i(_i) {}
	// 结构体类型优先级设置---方法一：重载小于号
	friend bool operator <(Node n1,Node n2) {
		return n1.d<n2.d;
		// 小于是大顶堆，元素从大到小
		// 大于是小顶堆，元素从小到大
	}
};
// 结构体类型优先级设置---方法二：重写仿函数
struct cmps {
	bool operator()(Node n1,Node n2) {
		return n1.d>n2.d;
	}
};
int main(int argc,char * argv[]) {
	printf("\n------------- 基本类型 ------------\n");
	priority_queue<int,vector<int>,greater<int>> gp; //小顶堆
	priority_queue<int,vector<int>,less<int>> lp; //大顶堆
	printf("\n- 小顶堆 -\n");
	gp.emplace(8);
	gp.emplace(6);
	gp.emplace(7);
	gp.emplace(5);
	while(!gp.empty()) {
		int a = gp.top();
		printf("%d",a);
		gp.pop();
	}
	printf("\n- 大顶堆 -\n");
	lp.emplace(8);
	lp.emplace(6);
	lp.emplace(7);
	lp.emplace(5);
	while(!lp.empty()) {
		int a = lp.top();
		printf("%d",a);
		lp.pop();
	}
	printf("\n------------- pair类型 ------------\n");
	printf("\n- 小顶堆 -\n");
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;
	pair<int,int> a(1,2);
	pair<int,int> b(1,3);
	pair<int,int> c(2,4);
	pair<int,int> d(2,3);
	pq.emplace(a);
	pq.emplace(b);
	pq.emplace(c);
	pq.emplace(d);
	while(!pq.empty()) {
		pair<int,int> ap = pq.top();
		printf("%d-%d\n",ap.first,ap.second);
		pq.pop();
	}
	printf("\n- 大顶堆 -\n");
	priority_queue<pair<int,int>,vector<pair<int,int>>,less<pair<int,int>>> pql;
	pql.emplace(a);
	pql.emplace(b);
	pql.emplace(c);
	pql.emplace(d);
	while(!pql.empty()) {
		pair<int,int> ap = pql.top();
		printf("%d-%d\n",ap.first,ap.second);
		pql.pop();
	}

	printf("\n------------- 结构体类型 ------------\n");
	priority_queue<Node,vector<Node>> gps; //小顶堆
	priority_queue<Node,vector<Node>,cmps> lps; //大顶堆
	printf("\n- 小顶堆 -\n");
	Node n1(3,1);
	Node n2(2,2);
	Node n3(4,3);
	gps.emplace(n1);
	gps.emplace(n2);
	gps.emplace(n3);
	while(!gps.empty()) {
		Node a = gps.top();
		printf("%d",a.d);
		gps.pop();
	}
	printf("\n- 大顶堆 -\n");
	lps.emplace(n1);
	lps.emplace(n2);
	lps.emplace(n3);
	while(!lps.empty()) {
		Node a = lps.top();
		printf("%d",a.d);
		lps.pop();
	}

	return 0;
}