优先队列几个应用详解

点击打开链接

优先级队列区别于普通队列的一点是：优先级队列如果插入的节点是结构体类型，则要在结构体中重载比较操作符函数。示例代码如下：

[cpp]  view plain  copy

1. //优先级队列的使用测试  
2. //优先级队列跟对列的使用方式的区别是优先级队列在插入元素时  
3. //在将元素插入队尾后还要根据比较值对该元素进行位置的调整  
4. #include<iostream>  
5. #include<queue>  
6. using namespace std;  
7. struct Node  
8. {  
9.     int key;  
10.     char ch;  
11.     //只有<重载操作符函数时，如果将<改为>为什么不行，出现error C2784的错误  
12.     friend bool operator <(Node node1,Node node2)  
13.     {  
14.         //<为从大到小排列，>为从小到大排列  
15.         return node1.key<node2.key;  
16.     }  
17.     friend bool operator >(Node node1,Node node2)  
18.     {  
19.         return node1.key<node2.key;  
20.     }  
21. };  
22. int main()  
23. {  
24.     //对于优先队列中包含结构体或者类的类型，该结构体或者类必须包含比较操作符的重载  
25.     //因为优先级队列在插入时，是按照结构体中的某一个元素进行比较，如果  
26.     //不重载比较操作符，优先级队列比较的是结构体，而我们知道结构体是无法直接进行比较的。  
27.     //如下定义优先级队列qu，less表示按照递减的顺序插入元素，换成greater则表示按照递增的  
28.     //方式插入元素  
29.     priority_queue<int,vector<int>,less<int>>qu;  
30.     //定义如下的que优先级队列，会默认按照从大到小对插入元素进行排列  
31.     //所以在没有定义<时，会出现错误  
32.     priority_queue<Node>que;  
33.     priority_queue<Node,vector<Node>,less<Node>>qe;  
34.     Node node[10];  
35.     int i;  
36.     int a[10]={4,2,1,3,6,8,7,9,10,5};  
37.     char b[10]={'a','b','c','d','e','f','g','h','i','j'};  
38.     //从小到大插入元素  
39.     for(i=0;i<10;i++)  
40.     {  
41.         qu.push(a[i]);  
42.     }  
43.     for(i=0;i<10;i++)  
44.     {  
45.         cout<<qu.top()<<endl;  
46.         qu.pop();  
47.     }  
48.     cout<<endl;  
49.     //默认从大到小插入元素  
50.     for(i=0;i<10;i++)  
51.     {  
52.         node[i].key=a[i];  
53.         node[i].ch=b[i];  
54.         que.push(node[i]);  
55.     }  
56.     for(i=0;i<10;i++)  
57.     {  
58.         cout<<que.top().key<<" "<<que.top().ch<<endl;  
59.         que.pop();  
60.     }  
61.     cout<<endl;  
62.     //利用了priority_queue<Node,vector<Node>,less<Node>>qe;这个定义后可以  
63.     //将元素从大到小插入元素，但是注意的是结构体中必须重载<操作符，不然会出错  
64.     for(i=0;i<10;i++)  
65.     {  
66.         node[i].key=a[i];  
67.         node[i].ch=b[i];  
68.         qe.push(node[i]);  
69.     }  
70.     for(i=0;i<10;i++)  
71.     {  
72.         cout<<qe.top().key<<" "<<qe.top().ch<<endl;  
73.         qe.pop();  
74.     }  
75.     return 0;  
76. }  

疑问解答：在编写代码的时候，在只有一个重载操作符函数<时，我们将<改为>，que.push(node)，出错，错误代号是：C2784.后来发现原因是：我们如下定义的que,  priority_queue<Node>que;而默认的que插入是从大到小，所以在结构体中要重载<,如果我们将其<修gai为>则que的push函数找不到相应的操作符，就会出错。

另外，如果我们想向优先级队列中插入指针元素时该怎么办？是不是将priority_queue<Node>que;改为priority_queue<Node*>que;就ok了？

不是！因为我们不能用结构体中重载的操作符对que中的元素进行比较，结构体中重载的操作符是类Node的操作符，而que中的是指针类型的Node节点，它与结构体中重载的操作符无法匹配。所以我们要另想办法。

那我们将friend bool operator >(Node node1,Node node2)修改为friend bool operator >(Node* node1,Node* node2)，也就是传递的是Node的指针行不行呢

答案是不可以，因为根据C++primer中重载操作符中讲的“程序员只能为类类型或枚举类型的操作数定义重载操作符，在吧操作符声明为类的成员是，至少有一个类或枚举类型的参数

按照值或者引用的方式传递”，也就是说friend bool operator >(Node* node1,Node* node2)形参中都是指针类型的是不可以的。我们可以如下解决此问题。

[cpp]  view plain  copy

1. //在优先级队列中存入指针类型的节点  
2. #include<iostream>  
3. #include<queue>  
4. using namespace std;  
5. class Comapre;  
6. class Node  
7. {  
8. private:  
9.     friend Comapre;  
10.     int key;  
11.     char ch;  
12. public:  
13.     Node(int num,char c):key(num),ch(c){}  
14.     bool lessthan (const Node* node) const  
15.     {  
16.         return key<node->key;  
17.     }  
18.     int GetKey()  
19.     {  
20.         return key;  
21.     }  
22.     char GetChar()  
23.     {  
24.         return ch;  
25.     }  
26. };  
27. class Comapre  
28. {  
29. public:  
30.     bool operator () (Node*node1,Node*node2)  
31.     {  
32.         return node1->lessthan(node2);  
33.     }  
34. };  
35. int main()  
36. {  
37.     Node *n1=new Node(5,'c');  
38.     Node *n2=new Node(4,'d');  
39.     Node *n3=new Node(6,'e');  
40.     priority_queue<Node*,vector<Node*>,Comapre>qu;  
41.     qu.push(n1);  
42.     qu.push(n2);  
43.     qu.push(n3);  
44.     int i;  
45.     for(i=0;i<3;i++)  
46.     {  
47.         cout<<qu.top()->GetKey()<<" "<<qu.top()->GetChar()<<endl;  
48.         qu.pop();  
49.     }  
50.     return 0;  
51. }