优先队列(priority queue)是队列(queue)的一种，是0个或多个元素的集合,每个元素都有一个优先权或值,它可以按照自定义的一种方式（数据的优先级）来对队列中的数据进行动态的排序。每次push和pop操作后，队列都会动态的调整，以达到我们预期的方式来存储。

优先队列执行的操作

1) 查找
2) 插入一个新元素
3) 删除

在最小优先队列(min priority queue)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素;
对于最大优先队列(max priority queue),查找操作用来搜索优先权最大的元素,删除操作用来删除该元素.
(优先权队列中的元素可以有相同的优先权,查找与删除操作可根据任意优先权进行.)

示例

1.标准库默认使用元素类型的<操作符来确定它们之间的优先级关系 - 默认<操作符在整数中元素大的优先级高

1
2
3
// 将元素5，3，2，4，6依次push到优先队列中
// print结果为： 6 5 4 3 2
priority_queue<int> pq;

2.数据越小，优先级越高

1
2
3
// 将元素5，3，2，4，6依次push到优先队列中
// print结果为： 2 3 4 5 6
priority_queue<int, vector<int>, greater<int> >pq;

3.自定义优先级，重载比较符号

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

重载 > 号会编译出错，因为标准库默认使用元素类型的 < 操作符来确定它们之间的优先级关系。而且自定义类型的 < 操作符与 > 操作符并无直接联系

priority queue的基本使用代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include<stdio.h>  
#include<functional>  
#include<queue>  
#include<vector>  
using namespace std;  

//定义结构，使用运算符重载,自定义优先级1  
struct cmp1{  
    bool operator ()(int &a,int &b){  
        return a>b;//最小值优先  
    }  
};  
struct cmp2{  
    bool operator ()(int &a,int &b){  
        return a<b;//最大值优先  
    }  
};
  
//定义结构，使用运算符重载,自定义优先级2  
struct number1{  
    int x;  
    bool operator < (const number1 &a) const {  
        return x>a.x;//最小值优先  
    }  
};  
struct number2{  
    int x;  
    bool operator < (const number2 &a) const {  
        return x<a.x;//最大值优先  
    }  
};  
int a[]={14,10,56,7,83,22,36,91,3,47,72,0};  
number1 num1[]={14,10,56,7,83,22,36,91,3,47,72,0};  
number2 num2[]={14,10,56,7,83,22,36,91,3,47,72,0};  
  
int main()  
{   priority_queue<int>que;//采用默认优先级构造队列   
    priority_queue<int,vector<int>,cmp1>que1;//最小值优先  
    priority_queue<int,vector<int>,cmp2>que2;//最大值优先  
    priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为是右移运算符，所以这里用空格号隔开      	priority_queue<int,vector<int>,less<int> >que4;//最大值优先  
    priority_queue<number1>que5;  
    priority_queue<number2>que6;  
    
    int i;  
    for(i=0;a[i];i++){  
        que.push(a[i]);  
        que1.push(a[i]);  
        que2.push(a[i]);  
        que3.push(a[i]);  
        que4.push(a[i]);  
    }  
    for(i=0;num1[i].x;i++)  
        que5.push(num1[i]);  
    for(i=0;num2[i].x;i++)  
        que6.push(num2[i]);  
  
  
    printf("采用默认优先关系:\n(priority_queue<int>que;)\n");  
    printf("Queue 0:\n");  
    while(!que.empty()){  
        printf("%3d",que.top());  
        que.pop();  
    }  
    puts("");  
    puts("");  
  
    printf("采用结构体自定义优先级方式一:\n(priority_queue<int,vector<int>,cmp>que;)\n");  
    printf("Queue 1:\n");  
    while(!que1.empty()){  
        printf("%3d",que1.top());  
        que1.pop();  
    }  
    puts("");  
    printf("Queue 2:\n");  
    while(!que2.empty()){  
        printf("%3d",que2.top());  
        que2.pop();  
    }  
    puts("");  
    puts("");  
    printf("采用头文件\"functional\"内定义优先级:\n(priority_queue<int,vector<int>,greater<int>/less<int> >que;)\n");  
    printf("Queue 3:\n");  
    while(!que3.empty()){  
        printf("%3d",que3.top());  
        que3.pop();  
    }  
    puts("");  
    printf("Queue 4:\n");  
    while(!que4.empty()){  
        printf("%3d",que4.top());  
        que4.pop();  
    }  
    puts("");  
    puts("");  
    printf("采用结构体自定义优先级方式二:\n(priority_queue<number>que)\n");  
    printf("Queue 5:\n");  
    while(!que5.empty()){  
        printf("%3d",que5.top());  
        que5.pop();  
    }  
    puts("");  
    printf("Queue 6:\n");  
    while(!que6.empty()){  
        printf("%3d",que6.top());  
        que6.pop();  
    }  
    puts("");  
    return 0;  
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
采用默认优先关系: 
(priority_queue<int>que;) 
Queue 0: 
 91 83 72 56 47 36 22 14 10  7  3 
 
采用结构体自定义优先级方式一: 
(priority_queue<int,vector<int>,cmp>que;) 
Queue 1: 
  3  7 10 14 22 36 47 56 72 83 91 
Queue 2: 
 91 83 72 56 47 36 22 14 10  7  3 
 
采用头文件"functional"内定义优先级: 
(priority_queue<int,vector<int>,greater<int>/less<int> >que;) 
Queue 3: 
  3  7 10 14 22 36 47 56 72 83 91 
Queue 4: 
 91 83 72 56 47 36 22 14 10  7  3 
 
采用结构体自定义优先级方式二: 
(priority_queue<number>que) 
Queue 5: 
  3  7 10 14 22 36 47 56 72 83 91 
Queue 6: 
 91 83 72 56 47 36 22 14 10  7  3