priority_queue（优先队列）用法总结

//转自shuangde800

优先队列(priority queue)

　　优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。

       首先它是一个队列，但是它强调了“优先”二字，所以，已经不能算是一般意义上的队列了，它的“优先”意指取队首元素时，有一定的选择性，即根据元素的属性选择某一项值最优的出队~

 

关于priority_queue
1,关于STL中的priority_queue:确定用top()查看顶部元素时,该元素是具有最高优先级的一个元素. 调用pop()删除之后,将促使下一个元素进入该位置. 
2,如同stack和queue,priority_queue是一个基于基本序列容器进行构建的适配器,默认的序列器是vector.
 

模板原型：

1. priority_queue<Type,Container,Compare>
3. // Type 为数据类型
4. // Container 为保存数据的容器, 必须是用数组实现的容器，比如 vector, deque 但不能用list。STL里面默认用的是 vector
5. // Compare为元素比较方式。. 比较方式默认用 operator< , 所以如果你把后面俩个参数缺省的话，优先队列就是大顶堆，队头元素最大。

 

常用的操作如下：

empty()  如果优先队列为空，则返回真 
pop()  删除第一个元素 
push()  加入一个元素 
size()  返回优先队列中拥有的元素的个数 
top()  返回优先队列中有最高优先级的元素 

 

但是在使用时必须注意：priority_queue放置元素时，不会判断元素是否重复。（因为在模板的第二个参数时顺序容器，不能保证元素的唯一性）此外可以替代默认的Compare函数

 

priority_queue 调用 STL里面的 make_heap(), pop_heap(), push_heap() 算法
实 现，也算是堆的另外一种形式。

先写一个用 STL 里面堆算法实现的与真正的STL里面的 priority_queue 用法相
似的 priority_queue， 以加深对 priority_queue 的理解

 

1. #include<iostream>
2. #include<algorithm>
3. #include<vector>
4. using namespace std;
6. class priority_queue {
8. private:
9. vector< int> data;
11. public:
12. void push( int t ){
13. data.push_back(t);
14. push_heap( data.begin(), data.end() );
15. }
16. void pop(){
17. pop_heap( data.begin(), data.end() );
18. }
19. int top() { return data.front(); }
20. int size() { return data.size(); }
21. bool empty() { return data.empty(); }
23. };
24. // STL里面的 priority_queue 写法与此相似，只是增加了模板及相关的迭代器什么的。
27. int main()
28. {
29. priority_queue test;
30. test.push( 3 );
31. test.push( 5 );
32. test.push( 2 );
33. test.push( 4 );
34. while( !test.empty() ){
35. cout << test.top() << endl;
36. test.pop();
37. }
38. return 0;
39. }

看例子：

1. #include<iostream>
2. #include<queue>
3. using namespace std;
4. int main()
5. {
6. priority_queue< int> q;
8. for( int i= 0; i< 10; ++i)
9. q.push( rand() );
11. while( !q.empty() ){
12. cout << q.top() << endl;
13. q.pop();
14. }
15. getchar();
17. return 0;
18. }

 

如果要用到小顶堆，则一般要把模板的三个参数都带进去。

STL里面定义了一个仿函数 greater<>，对于基本类型可以用这个仿函数声明小顶堆。( less< >则是从大到小)
例子:

1. #include <iostream>
2. #include <queue>
3. using namespace std;
5. int main()
6. {
7. priority_queue< int, vector< int>, greater< int> > q; //注意 greater<int>和后面一个'>'要有空格分开!
9. for( int i= 0; i< 10; ++i )
10. q.push( rand() );
12. while( !q.empty() ){
13. cout << q.top() << endl;
14. q.pop();
15. }
17. getchar();
18. return 0;
19. }

对于自定义类型，则必须自己重载 operator< 或者自己写仿函数
先看看例子:

1. #include<iostream>
2. #include<queue>
3. using namespace std;
5. struct Node{
6. int x;
7. int y;
8. Node( int a= 0, int b= 0): x(a),y(b) { }
9. };
11. bool operator < (Node a, Node b){
12. if(a.x == b.x)
13. return (a.y > b.y);
14. return (a.x > b.x);
15. }
18. int main()
19. {
20. priority_queue<Node>q;
21. for( int i= 0; i< 10; ++i)
22. q.push( Node( rand(), rand() ) );
23. while( !q.empty() ){
24. cout << q.top().x<< " "<<q.top().y<< endl;
25. q.pop();
26. }
27. getchar();
28. return 0;
29. }

自定义类型重载 operator< 后，声明对象时就可以只带一个模板参数。

但此时不能像基本类型这样声明priority_queue<Node, vector<Node>, greater<Node> >;原因是 greater<Node> 没有定义，如果想用这种方法定义则可以按如下方式

例子:

1. #include<iostream>
2. #include<queue>
3. using namespace std;
5. struct Node{
6. int x;
7. int y;
8. Node( int a= 0, int b= 0 ): x(a),y(b) { }
9. };
11. struct cmp{
12. bool operator() ( Node a, Node b ){
13. if( a.x==b.x )
14. return a.y>b.y;
15. return a.x>b.x;
16. }
17. };
19. int main()
20. {
21. priority_queue<Node, vector<Node>,cmp> q;
23. for( int i= 0; i< 10; ++i)
24. q.push( Node( rand(), rand() ) );
25. while( !q.empty() ){
26. cout << q.top().x << " "<< q.top().y << endl;
27. q.pop();
28. }
30. getchar();
31. return 0;
32. }

 

以上例子的

1. struct cmp{
2. bool operator() ( Node a, Node b ){
3. if( a.x==b.x )
4. return a.y>b.y;
5. return a.x>b.x;
6. }
7. };

为重点。

 

例2：

 

1. #include<iostream>
2. #include<functional>
3. #include<cstdlib>
4. #include<algorithm>
5. #include<queue>
6. #include<set>
7. #include<vector>
8. #include<string>
9. using namespace std;
11. struct Node{
12. int data;
13. Node() {}
14. Node( int n ) { data=n; }
15. };
17. struct myCmp: binary_function< Node,Node, bool >{
18. bool operator () (const Node &a,const Node &b) {
19. return a.data < b.data;
20. }
21. };
23. /*
24. 根据实践即便不从 binary_function 派生也是可以使用的
26. class myCmp{
27. public:
28. bool operator () (const Node& a,const Node& b){
29. return a.data < b.data;
30. }
31. };
33. */
34. int main()
35. {
36. priority_queue<Node, vector<Node>,myCmp> PQ;
38. set<Node,myCmp> s;
39. Node arr[ 6]={ 1, -1, 2, -2, 3, -3};
40. sort(arr,arr+ 6,myCmp() );
42. return 0;
43. }