c++优先队列（priority_queue）⽤法详解
介绍：
普通的队列是⼀种先进先出的数据结构，元素在队列尾追加，⽽从队列头删除。
在优先队列中，元素被赋予优先级。当访问元素时，具有最⾼优先级的元素最先删除。优先队列具有最⾼级先出（first in, largest out）的⾏为特征。
⾸先要包含头⽂件#include<queue>, 他和queue不同的就在于我们可以⾃定义其中数据的优先级, 让优先级⾼的排在队列前⾯，优先出队。
优先队列具有队列的所有特性，包括队列的基本操作，只是在这基础上添加了内部的⼀个排序，它本质是⼀个堆实现的。
和队列相同的基本操作:
top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插⼊元素到队尾 (并排序)
emplace 原地构造⼀个元素并插⼊队列
pop 弹出队头元素
swap 交换内容
定义：
priority_queue<Type, Container, Functional>
Type 就是数据类型，Container 就是容器类型（Container必须是⽤数组实现的容器，⽐如vector,deque等等，但不能⽤ list。STL⾥⾯默认⽤的是vector），Functional 就是⽐较的⽅式。
当需要⽤⾃定义的数据类型时才需要传⼊三个参数(因为此时需要重写⾃⼰数据的Functional，也就是为⾃⼰的数据重载<(⼤顶堆)或>(⼩顶堆) )，使⽤基本数据类型时，只需要传⼊数据类型，默认是⼤顶堆。
⼀般是：
//升序队列，⼩顶堆
priority_queue <int,vector<int>,greater<int> > q;
//降序队列，⼤顶堆
priority_queue <int,vector<int>,less<int> >q;
//greater和less是std实现的两个仿函数（就是使⼀个类的使⽤看上去像⼀个函数。其实现就是类中实现⼀个operator()，这个类就有了类似函数的⾏为，就是⼀个仿函数类了）1>基本类型优先队列的例⼦：
#include<iostream>
#include <queue>
using namespace std;
int main()
{
//对于基础类型默认是⼤顶堆
priority_queue<int> a;
//等同于 priority_queue<int, vector<int>, less<int> > a;
// 这⾥⼀定要有空格，不然成了右移运算符↓↓
priority_queue<int, vector<int>, greater<int> > c; //这样就是⼩顶堆
priority_queue<string> b;
for (int i = 0; i < 5; i++)
{
a.push(i);
c.push(i);
}
while (!a.empty())
{
cout << a.top() << '';
a.pop();
}
cout << endl;
while (!c.empty())
{
cout << c.top() << '';
c.pop();
}
cout << endl;
b.push("abc");
b.push("abcd");
b.push("cbd");
while (!b.empty())
{
cout << b.top() << '';
b.pop();
}
cout << endl;
return0;
}
运⾏结果：
43210
01234
cbd abcd abc
请按任意键继续. . .
2>⽤pair做优先队列元素的例⼦：
规则：pair的⽐较，先⽐较第⼀个元素，第⼀个相等⽐较第⼆个。#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main()
{
priority_queue<pair<int, int> > a;
pair<int, int> b(1, 2);
pair<int, int> c(1, 3);
pair<int, int> d(2, 5);
a.push(d);
a.push(c);
a.push(b);
while (!a.empty())
{
cout << a.top().first << '' << a.top().second << '\n';
a.pop();
}
}
运⾏结果：
25
13
12
请按任意键继续. . .
3>⽤⾃定义类型做优先队列元素的例⼦
#include <iostream>
container容器用法
#include <queue>
using namespace std;
//⽅法1
struct tmp1 //运算符重载<
{
int x;
tmp1(int a) {x = a;}
bool operator<(const tmp1& a) const
{
return x < a.x; //⼤顶堆
}
};
//⽅法2
struct tmp2 //重写仿函数
{
bool operator() (tmp1 a, tmp1 b)
{
return a.x < b.x; //⼤顶堆
}
};
int main()
{
tmp1 a(1);
tmp1 b(2);
tmp1 c(3);
priority_queue<tmp1> d;
d.push(b);
d.push(c);
d.push(a);
while (!d.empty())
{
cout << d.top().x << '\n';
d.pop();
}
cout << endl;
priority_queue<tmp1, vector<tmp1>, tmp2> f;
f.push(b);
f.push(c);
f.push(a);
while (!f.empty())
cout << f.top().x << '\n';
f.pop();
}
}
运⾏结果：
3
2
1
3
2
1
请按任意键继续. . .
3>emplace⽅法
VS2017中的emplace源码
1 template& _Valty>
2void emplace(_Valty&&... _Val)
3 { // insert element at beginning
4 c.emplace_back(_STD forward<_Valty>(_Val)...);
5 _STD push_heap(c.begin(), c.end(), comp);
6 }
VS2017中的push源码
1void push(value_type&& _Val)
2 { // insert element at beginning
3 c.push_back(_STD move(_Val));
4 _STD push_heap(c.begin(), c.end(), comp);
5 }
两个⽅法的主要区别：在将新添加的元素堆中之前⼀个调⽤的是emplace_back（）⽅法，⼀个调⽤的是push_back（）⽅法。
下⾯主要分析emplace_back（）⽅法和push_back（）⽅法的区别：
c++开发中我们会经常⽤到插⼊操作对stl的各种容器进⾏操作，⽐如vector,map,set等。在引⼊右值引⽤，转移构造函数，转移复制运算符之前，通常使⽤push_back()向容器中加⼊⼀个右值元素(临时对象)时，⾸先会调⽤构造函数构造这个临时对象，然后需要调⽤拷贝构造函数将这个临时对象放⼊容器中。原来的临时变量释放。这样造成的问题就是临时变量申请资源的浪费。
引⼊了右值引⽤，转移构造函数后，push_back()右值时就会调⽤构造函数和转移构造函数，如果可以在插⼊的时候直接构造，就只需要构造⼀次即可。这就是c++11 新加的emplace_back。
因此，优先队的push⽅法和emplace⽅法在功能上并没有很⼤的区别，只有实现上的细微区别。
现在测试⼀下：
由于STL优先队列实际上就是有heap的⽅法实现的所以先测试heap中的push_back()和emplace_back()，这值得容器⽤vector实现。
使⽤push_heap将新元素⼊堆之前调⽤emplace_back()：
1 #include <iostream>
2 #include <vector>
3 #include <algorithm>
4 #include <queue>
5
6using namespace std;
7
8void printHeap(vector<int> &v) {
9for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
10 cout << *it << "";
11 }
12 cout << "\n" << endl;
13 }
14
15int main()
16 {
17 vector<int> min = { 10,30,22,6,15,9 };
18
19//建⽴⼩顶堆
20 make_heap(min.begin(), d(), greater<int>());
21 printHeap(min);//6 10 9 30 15 22
22
23//插⼊元素
24 place_back(20);
25 push_heap(min.begin(), d(), greater<int>());//该算法前提：必须在堆的条件下
26 printHeap(min);
27
28return0;
29 }
输出：
使⽤push_heap将新元素⼊堆之前调⽤push_back()：
1 #include <iostream>
2 #include <vector>
3 #include <algorithm>
4 #include <queue>
5
6using namespace std;
7
8void printHeap(vector<int> &v) {
9for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
10 cout << *it << "";
11 }
12 cout << "\n" << endl;
13 }
14
15int main()
16 {
17 vector<int> min = { 10,30,22,6,15,9 };
18
19//建⽴⼩顶堆
20 make_heap(min.begin(), d(), greater<int>());
21 printHeap(min);//6 10 9 30 15 22
22
23//插⼊元素
24 min.push_back(20);
25 push_heap(min.begin(), d(), greater<int>());//该算法前提：必须在堆的条件下
26 printHeap(min);
27
28return0;
29 }
输出：
现在直接使⽤priority_queue来测试emplace和push：
1 #include <iostream>
2 #include <vector>
3 #include <algorithm>
4 #include <queue>
5
6using namespace std;
7
8void printHeap(vector<int> &v) {
9for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
10 cout << *it << "";
11 }
12 cout << "\n" << endl;
13 }
14
15int main()
16 {
17
18 priority_queue<int, vector<int>, less<int> > pq;
19 pq.push(6);
20 pq.push(15);
21 pq.push(9);
22 pq.push(10);
23 pq.push(30);
24 pq.push(22);
25
26 auto tpd = pq;
27while (!pty()) {
28 cout << p() << "";
29 tpd.pop();
30 }
31 cout << endl;
32
33 auto tpd1 = pq;
34 tpd1.push(16);
35while (!pty()) {
36 cout << p() << "";
37 tpd1.pop();
38 }
39 cout << endl;
40
41
42 auto tpd2 = pq;
43 place(16);
44while (!pty()) {
45 cout << p() << "";
46 tpd2.pop();
47 }
48 cout << endl;
49
50return0;
51 }
输出：
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论