优先级队列

概念

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

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

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

最小优先级队列

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

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

int left(int index)
{
    return (index*2);
}

int right(int index)
{
    return (index*2+1);
}

int parent(int index)
{
    return (index/2);
}


void MinHeapify(int* A,int heapSize,int index)
{
    int l,r;
    int least;//记录最小节点坐标
    int tmp;

    l = left(index);
    r = right(index);
    least = index;

    if((l <= heapSize) && (A[l] < A[index]))
    {
        least = l;
    }

    if((r <= heapSize) && (A[r] < A[least]))
    {
        least = r;
    }

    if(least != index)
    {
        tmp = A[least];
        A[least] = A[index];
        A[index] = tmp;
        MinHeapify(A,heapSize,least);
    }
}

void BuildMinHeap(int* A,int heapSize)
{
    for(int i = heapSize/2 ; i >= 1; i--)
    {
        MinHeapify(A,heapSize,i);
    }
}

int Minimum(int* A)
{
    return A[1];
}

最小优先级队列操作

获得队首元素

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

代码如下：

int Minimum(int* A)
{
    return A[1];
}

队首元素出队列

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

代码如下：

int HeapExtractMin(int* A,int& heapSize)
{
    if(heapSize < 1)
    {
        printf("堆下溢！\n");
        return MAXVALUE;//由于下溢，随便随便返回一个值
    }

    int min;

    min = A[1];
    A[1] = A[heapSize];
    heapSize--;

    MinHeapify(A,heapSize,1);

    return min;

}

修改元素

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

代码如下：

void HeapDecreaseVal(int* A,int index,int val)
{
    if( val > A[index])
    {
        printf("新值比当前值大！\n");
        return ;
    }

    int tmp;

    A[index] = val;

    while((index > 1) && (A[parent(index)] > A[index]))
    {//维护小根堆
        tmp = A[parent(index)];
        A[parent(index)] = A[index];
        A[index] = tmp;
        index = parent(index);
    }
}

 

插入

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

代码如下：

void MinHeapInsert(int* A,int& heapSize,int val)
{
    heapSize++;
    A[heapSize] = MAXVALUE;//MAXVALUE表示无限大
    HeapDecreaseVal(A,heapSize,val);
}

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

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

struct node
{
    friend bool operator< (node n1, node n2)
    {
        return n1.priority < n2.priority;
    }
    int priority;
    int value;
};

在该结构中，value为值，priority为优先级。
通过自定义operator<操作符来比较元素中的优先级。
在示例3中输出结果为：
优先级      值
9          5
8          2
6          1
2          3
1          4
但如果结构定义如下：

struct node
{
    friend bool operator> (node n1, node n2)
    {
        return n1.priority > n2.priority;
    }
    int priority;
    int value;
};

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

使用方法代码如下：

#include<iostream>
#include<functional>
#include<queue>
using Namespace stdnamespace std;
struct node
{
    friend bool operator< (node n1, node n2)
    {
        return n1.priority < n2.priority;
    }
    int priority;
    int value;
};
int main()
{
    const int len = 5;
    int i;
    int a[len] = {3,5,9,6,2};
    //示例1
    priority_queue<int> qi;
    for(i = 0; i < len; i++)
        qi.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi.top()<<" ";
        qi.pop();
    }
    cout<<endl;
    //示例2
    priority_queue<int, vector<int>, greater<int> >qi2;
    for(i = 0; i < len; i++)
        qi2.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi2.top()<<" ";
        qi2.pop();
    }
    cout<<endl;
    //示例3
    priority_queue<node> qn;
    node b[len];
    b[0].priority = 6; b[0].value = 1; 
    b[1].priority = 9; b[1].value = 5; 
    b[2].priority = 2; b[2].value = 3; 
    b[3].priority = 8; b[3].value = 2; 
    b[4].priority = 1; b[4].value = 4; 
 
    for(i = 0; i < len; i++)
        qn.push(b[i]);
    cout<<"优先级"<<'\t'<<"值"<<endl;
    for(i = 0; i < len; i++)
    {
        cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;
        qn.pop();
    }
    return 0;
}