【c++——STL】标准模板库STL中优先队列Priority Queues使用手册

转自博客：

http://blog.youkuaiyun.com/yuanjilai/article/details/8043157

优先队列容器默认使用向量容器实现，用户也可以使用双端队列容器。优先队列总是把优先级最高的元素放在队列的最前方，来保持队列的有序性。

插入操作push()使用一个双变量的布尔函数，将队列中的元素重新排序，以满足这个要求。

该函数可以由用户提供，否则可以使用<操作符，元素越大，优先级越高。

如果元素越小，优先级越高，则需要使用函数对象greater，表明在决定向优先级队列中插入新元素时，push()应该使用的操作符是>而不是<.

 

 成员函数：

empty	true if the priority queue has no elements
pop	removes the top element of a priority queue
push	adds an element to the end of the priority queue
size	returns the number of items in the priority queue
top	returns the top element of the priority queue

 

在优先队列中，优先级高的元素先出队列。标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。

优先队列的第一种用法，也是最常用的用法：

[cpp]  view plain copy

1. priority_queue<int> qi;  

通过<操作符可知在整数中元素大的优先级高。

故示例1中输出结果为：9 6 5 3 2

第二种方法：

在示例1中，如果我们要把元素从小到大输出怎么办呢？

这时我们可以传入一个比较函数，使用functional.h函数对象作为比较函数。

[cpp]  view plain copy

1. priority_queue<int, vector<int>, greater<int> > qi2;  

其中

第二个参数为容器类型。

第三个参数为比较函数。

故示例2中输出结果为：2 3 5 6 9

第三种方法：自定义优先级。

[cpp]  view plain copy

1. struct node  
2. {  
3.     friend bool operator< (node n1, node n2)  
4.     {  
5.         return n1.priority < n2.priority;  
6.     }  
7.     int priority;  
8.     int value;  
9. };  

在该结构中，value为值，priority为优先级。

通过自定义operator<操作符来比较元素中的优先级。

在示例3中输出结果为：

优先级  值

9          5

8          2

6          1

2          3

1          4

但如果结构定义如下：

[cpp]  view plain copy

1. struct node  
2. {  
3.     friend bool operator> (node n1, node n2)  
4.     {  
5.         return n1.priority > n2.priority;  
6.     }  
7.     int priority;  
8.     int value;  
9. };  

则会编译不过（G++编译器）因为标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。而且自定义类型的<操作符与>操作符并无直接联系，故会编译不过。

//代码清单

[cpp]  view plain copy

1. #include<iostream>  
2. #include<functional>  
3. #include<queue>  
4. using namespace std;  
5. struct node  
6. {  
7.     friend bool operator< (node n1, node n2)  
8.     {  
9.         return n1.priority < n2.priority;  
10.     }  
11.     int priority;  
12.     int value;  
13. };  
14. int main()  
15. {  
16.     const int len = 5;  
17.     int i;  
18.     int a[len] = {3,5,9,6,2};  
19.     //示例1  
20.     priority_queue<int> qi;  
21.     for(i = 0; i < len; i++)  
22.         qi.push(a[i]);  
23.     for(i = 0; i < len; i++)  
24.     {  
25.         cout<<qi.top()<<" ";  
26.         qi.pop();  
27.     }  
28.     cout<<endl;  
29.     //示例2  
30.     priority_queue<int, vector<int>, greater<int> >qi2;  
31.     for(i = 0; i < len; i++)  
32.         qi2.push(a[i]);  
33.     for(i = 0; i < len; i++)  
34.     {  
35.         cout<<qi2.top()<<" ";  
36.         qi2.pop();  
37.     }  
38.     cout<<endl;  
39.     //示例3  
40.     priority_queue<node> qn;  
41.     node b[len];  
42.     b[0].priority = 6; b[0].value = 1;   
43.     b[1].priority = 9; b[1].value = 5;   
44.     b[2].priority = 2; b[2].value = 3;   
45.     b[3].priority = 8; b[3].value = 2;   
46.     b[4].priority = 1; b[4].value = 4;   
47.       
48.     for(i = 0; i < len; i++)  
49.         qn.push(b[i]);  
50.     cout<<"优先级"<<'\t'<<"值"<<endl;  
51.     for(i = 0; i < len; i++)  
52.     {  
53.         cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;  
54.         qn.pop();  
55.     }  
56.     return 0;  
57. }  

 另外贴一段优先队列使用的代码：

[cpp]  view plain copy

1. #include<iostream>  
2. #include<functional>  
3. #include<queue>  
4. #include<vector>  
5. using namespace std;  
6.   
7.   
8. struct cmp1  
9. {  
10.     bool operator () (int &a, int &b)  
11.     {  
12.         return a > b ;              // 从小到大排序，值 小的 优先级别高  
13.     }  
14. };  
15.   
16. struct cmp2  
17. {  
18.     bool operator () (int &a, int &b)  
19.     {  
20.         return a < b;             // 从大到小  
21.     }  
22. };  
23.   
24. struct number1  
25. {  
26.     int x;  
27.     bool operator < (const number1 &a)const   
28.     {  
29.         return x > a.x;         // 从小到大  ，x 小的 优先级别高  
30.     }  
31. };  
32.   
33. struct number2  
34. {  
35.     int x;  
36.     bool operator < (const number2 &a)const  
37.     {  
38.         return x < a.x;            // 从大到小  ，x 大的优先级别高  
39.     }  
40. };  
41.   
42. int a[] = {14,10,56,7,83,22,36,91,3,47,72,0};  
43. number1 num1[] ={14,10,56,7,83,22,36,91,3,47,72,0};  
44. number2 num2[] ={14,10,56,7,83,22,36,91,3,47,72,0};  
45.   
46. int main()  
47. {  
48.     priority_queue<int>que;  // 采用默认优先级构造队列  从大到小。   
49.   
50.     priority_queue<int, vector<int>, cmp1 >que1;  
51.     priority_queue<int, vector<int>, cmp2 >que2;  
52.   
53.     priority_queue<int, vector<int>, greater<int> > que3;  //functional 头文件自带的   
54.     priority_queue<int, vector<int>, less<int> > que4;      //functional 头文件自带的   
55.   
56.     priority_queue<number1> que5;  
57.     priority_queue<number2> que6;  
58.   
59.   
60.     int i;  
61.     for(i=0;a[i];i++)  
62.     {  
63.         que.push(a[i]);  
64.         que1.push(a[i]);  
65.         que2.push(a[i]);  
66.         que3.push(a[i]);  
67.         que4.push(a[i]);  
68.   
69.     }  
70.   
71.      for(i=0;num1[i].x;i++)  
72.          que5.push(num1[i]);  
73.      for(i=0;num2[i].x;i++)   
74.          que6.push(num2[i]);  
75.   
76.     printf("采用默认优先关系:\n(priority_queue<int>que;)\n");  
77.     printf("Queue 0:\n");  
78.         while(!que.empty())  
79.     {  
80.         printf("%3d",que.top());  
81.         que.pop();  
82.     }  
83.     puts("");  
84.     puts("");  
85.       
86.     printf("采用结构体自定义优先级方式一:\n(priority_queue<int,vector<int>,cmp>que;)\n");  
87.     printf("Queue 1:\n");  
88.     while(!que1.empty())  
89.     {  
90.         printf("%3d",que1.top());  
91.         que1.pop();  
92.     }  
93.     puts("");  
94.   
95.     printf("Queue 2:\n");  
96.         while(!que2.empty())  
97.     {  
98.         printf("%3d",que2.top());  
99.         que2.pop();  
100.     }  
101.     puts("");  
102.     puts("");  
103.   
104.     printf("采用头文件\"functional\"内定义优先级：\n(priority_queue<int, vector<int>,greater<int>/less<int> >que;)\n");  
105.     printf("Queue 3:\n");  
106.     while(!que3.empty())  
107.     {  
108.         printf("%3d",que3.top());  
109.         que3.pop();  
110.     }  
111.     puts("");  
112.   
113.     printf("Queue 4 :\n");  
114.     while(!que4.empty())  
115.     {  
116.         printf("%3d",que4.top());  
117.         que4.pop();  
118.     }  
119.     puts("");  
120.     puts("");  
121.   
122.     printf("采用结构体自定义优先级方式二:\n(priority_queue<number>que)\n");  
123.     printf("Queue 5:\n");  
124.     while(!que5.empty())  
125.     {  
126.         printf("%3d",que5.top());  
127.         que5.pop();  
128.     }  
129.     puts("");  
130.   
131.     printf("Queue 6:\n");  
132.     while(!que6.empty())  
133.     {  
134.         printf("%3d",que6.top());  
135.         que6.pop();  
136.     }  
137.   
138.     return 0;  
139. }  

执行结果：

 

 

九月网易有道招聘上机题：

给出大小为N的数组，用最快的办法找出前M个大的数字。

[cpp]  view plain copy

1. #include <iostream>  
2. #include <functional>  
3. #include <queue>  
4.   
5. using namespace std;  
6.   
7. int main()  
8. {  
9.     priority_queue<int,vector<int>, greater<int> > q;//从小到大  
10.     int n,m,num;  
11.     while (cin>>n>>m)  
12.     {  
13.         int i;  
14.         for (i = 0; i < m; i ++)  
15.         {  
16.             cin>>num;  
17.             q.push(num);  
18.         }  
19.         for (; i < n; i ++)  
20.         {  
21.             cin>>num;  
22.             if (num > q.top())  
23.             {  
24.                 q.pop();  
25.                 q.push(num);  
26.             }  
27.         }  
28.         while (!q.empty())  
29.         {  
30.             cout<<q.top()<<" ";  
31.             q.pop();  
32.         }  
33.         cout<<endl;  
34.     }  
35.     return 0;  
36. }  

 

这个题目可以用一个大小是M的最小堆来实现，初始建堆用数组前M个建好后，如果后面的元素a[i] 大于堆顶元素，那么就删除堆顶，插入新的元素。