《C++实现数据结构》：优先权队列

一个大小为n的堆是一棵包含n个结点的完全二叉树，该树中每个结点的关键字大于等于其双亲结点的关键字值。完全二叉树的根称为堆顶，若它的关键字值是整棵树上最大的，我们称之为最大堆。反之，就是最小堆。
如果要求每次从数据结构中取出的元素是具有最高优先级的元素，这样的数据结构被称为优先权队列。可见，堆是实现优先权队列的非常有效的数据结构。另外，因为堆的特性，我们还可以用堆来实现排序，也就是堆排序了。堆排序的具体实现在后面实现各种排序算法时再说明了。现在来看看优先权队列是怎么实现的。

//
// Created by huxijie on 17-3-20.
// 用最大堆来实现优先权队列

#include <iostream>
using namespace std;

template <typename T>
class PrioQueue{
private:
    T* q;
    int n,maxSize;          //maxSize是容量上限,n是队列中已有的数据个数
    void Swim(int k);       //上游,也就是向上调整
    void Sink(int k);       //下沉,也就是向下调整
    bool Less(int i, int j);
    void Swap(int i, int j);

public:
    PrioQueue();
    PrioQueue(int mSize);
    ~PrioQueue();
    bool IsEmpty() const;
    bool IsFull() const;
    bool GetMax(T &x);      //在x中返回具有最高优先权的元素值,并从优先权队列中删除该元素,返回true
    bool Append(const T &x); //元素值x加入队列
};

template <typename T>
PrioQueue<T>::PrioQueue() {
    this->PrioQueue(20);
}

template <typename T>
PrioQueue<T>::PrioQueue(int mSize) {
    maxSize = mSize;
    n = 0;
    q = new T[maxSize];
}

template <typename T>
PrioQueue<T>::~PrioQueue() {
    delete[]q;
}

template <typename T>
bool PrioQueue<T>::IsEmpty() const {
    return 0 == n;
}

template <typename T>
bool PrioQueue<T>::IsFull() const {
    return maxSize == n;
}

template <typename T>
bool PrioQueue<T>::Less(int i, int j) {
    if (q[i] < q[j]) {
        return true;
    } else {
        return false;
    }
}

template <typename T>
void PrioQueue<T>::Swap(int i, int j) {
    T tmp = q[i];
    q[i] = q[j];
    q[j] = tmp;
}

template <typename T>
void PrioQueue<T>::Swim(int k) {
    //如果父结点比子结点小,一直向上调整
    while (k >= 1 && Less((k - 1) / 2, k)) {
        Swap((k - 1) / 2, k);
        k = (k - 1) / 2;
    }
}

template <typename T>
void PrioQueue<T>::Sink(int k) {
    int i;
    while (2 * k + 1 < n) {
        i = 2 * k + 1;
        //如果有右孩子并且右孩子比左孩子大
        if (i < n && Less(i, i + 1)) {
            i++;
        }
        if (!Less(k, i)) {  //父结点比子结点大,向下调整结束
            break;
        } else {
            Swap(k, i);
            k = i;
        }
    }
}

template <typename T>
bool PrioQueue<T>::GetMax(T &x) {
    if (IsEmpty()) {
        cout<<"Empty"<<endl;
        return false;
    } else {
        x = q[0];   //得到优先权最大的元素
        q[0] = q[--n];  //将最后一个元素赋给根结点,结点数量减1
        Sink(0);    //从根结点向下调整堆
        return true;
    }
}

template <typename T>
bool PrioQueue<T>::Append(const T &x) {
    if (IsFull()) {
        cout<<"Full"<<endl;
        return false;
    } else {
        q[n++] = x; //加入到堆底,结点数量加1
        Swim(n-1);  //从堆底向上调整堆
        return true;
    }
}

int main() {
    int n = 10;
    PrioQueue<int> prioQueue(n);
    for (int i = 0; i < n; ++i) {
        prioQueue.Append(i);
    }
    prioQueue.Append(10);
    int max = 0;
    if (prioQueue.GetMax(max)) {
        cout<<max<<endl;
    }
    prioQueue.Append(10);
    if (prioQueue.GetMax(max)) {
        cout<<max<<endl;
    }

    return 0;
}

运行结果：

Full
9
10

Process finished with exit code 0