优先级队列

概念

　　优先级队列是一种用来维护一组元素集合的数据结构，这一组元素都具有关键字key，对于此队列，优先级高的先出队列，优先级低的后出队列。有两种优先级队列：

1.最大优先级队列：关键字越大，优先级越高，其本身建立在大根堆之上。

2.最小优先级队列：关键字越小，优先级越小，其本身建立在小根堆之上。

最小优先级队列

　　由于两种队列在实现的时候相类似，因此在此只介绍最小优先级队列。如果对对堆这个概念不是很清楚，可以参考下Howey写的堆排序。网址为：http://www.cnblogs.com/heweiyou1993/p/3330195.html

在此先给出小根堆核心代码：

 1 int left(int index)

 2 {

 3     return (index*2);

 4 }

 5 

 6 int right(int index)

 7 {

 8     return (index*2+1);

 9 }

10 

11 int parent(int index)

12 {

13     return (index/2);

14 }

15 

16 

17 void MinHeapify(int* A,int heapSize,int index)

18 {

19     int l,r;

20     int least;//记录最小节点坐标

21     int tmp;

22 

23     l = left(index);

24     r = right(index);

25     least = index;

26 

27     if((l <= heapSize) && (A[l] < A[index]))

28     {

29         least = l;

30     }

31 

32     if((r <= heapSize) && (A[r] < A[least]))

33     {

34         least = r;

35     }

36 

37     if(least != index)

38     {

39         tmp = A[least];

40         A[least] = A[index];

41         A[index] = tmp;

42         MinHeapify(A,heapSize,least);

43     }

44 }

45 

46 void BuildMinHeap(int* A,int heapSize)

47 {

48     for(int i = heapSize/2 ; i >= 1; i--)

49     {

50         MinHeapify(A,heapSize,i);

51     }

52 }

53 

54 int Minimum(int* A)

55 {

56     return A[1];

57 }

最小优先级队列操作

获得队首元素

　　队首元素的获得即获得堆的根节点，即A[1]。

代码如下：

1 int Minimum(int* A)

2 {

3     return A[1];

4 }

队首元素出队列

　　在堆中出队列，大体思想就是将根节点换掉即可，那么换掉之后必然需要让一个元素成为队首，这个时候有可能并不满足小根堆的性质，因此需要对其进行维护，为了便于维护，堆中的最后一个元素必然是不二之选。

代码如下：

 1 int HeapExtractMin(int* A,int& heapSize)

 2 {

 3     if(heapSize < 1)

 4     {

 5         printf("堆下溢！\n");

 6         return MAXVALUE;//由于下溢，随便随便返回一个值

 7     }

 8 

 9     int min;

10 

11     min = A[1];

12     A[1] = A[heapSize];

13     heapSize--;

14 

15     MinHeapify(A,heapSize,1);

16 

17     return min;

18 

19 }

修改元素

　　对于元素的修改，必须满足的条件是，修改后的值要不比当前值大，修改之后由于是否还满足小根堆性质的不确定性还需对堆进行维护。

代码如下：

 1 void HeapDecreaseVal(int* A,int index,int val)

 2 {

 3     if( val > A[index])

 4     {

 5         printf("新值比当前值大！\n");

 6         return ;

 7     }

 8 

 9     int tmp;

10 

11     A[index] = val;

12 

13     while((index > 1) && (A[parent(index)] > A[index]))

14     {//维护小根堆

15         tmp = A[parent(index)];

16         A[parent(index)] = A[index];

17         A[index] = tmp;

18         index = parent(index);

19     }

20 }

 

插入

　　向队列尾部添加元素即可，不过出于插入之后该堆是否依然满足小根堆性质的不确定性，维护该小顶堆还是再所难免的。

代码如下：

1 void MinHeapInsert(int* A,int& heapSize,int val)

2 {

3     heapSize++;

4     A[heapSize] = MAXVALUE;//MAXVALUE表示无限大

5     HeapDecreaseVal(A,heapSize,val);

6 }

STL之优先队列（以下内容转自NOCOW）

优先队列用法

在优先队列中，优先级高的元素先出队列。
标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。
优先队列的第一种用法，也是最常用的用法：
priority_queue<int> qi;

通过<操作符可知在整数中元素大的优先级高。
故示例1中输出结果为：9 6 5 3 2

第二种方法：
在示例1中，如果我们要把元素从小到大输出怎么办呢？
这时我们可以传入一个比较函数，使用functional.h函数对象作为比较函数。
priority_queue<int, vector<int>, greater<int> >qi2;

其中
第二个参数为容器类型。
第二个参数为比较函数。
故示例2中输出结果为：2 3 5 6 9

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

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
但如果结构定义如下：

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

使用方法代码如下：

 1 #include<iostream>

 2 #include<functional>

 3 #include<queue>

 4 using Namespace stdnamespace 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 }