堆实现优先队列

算法介绍：

【每日算法】堆排序&优先队列

代码实现：

#include <iostream>
#include <stdlib.h>
#include <string>
#define MAX 123456

using namespace std;

class PriorityQueue
{
private:
    int A[1123]; /// 堆化数组
    int heapSize;
public:

    /// 初始化
    PriorityQueue(){heapSize = 0;}

    /// 插入元素
    void INSERT(int key);
    /// 将元素x的关键字值增加到k
    void INCREASE_KEY(int i,int key);

    /// 返回具有最小关键字的元素
    int MINIMUM();

    /// 去掉并且返回具有最小关键字的元素
    void EXTRACT_MIN();
    /// 调整
    void MIN_HEAPIFY(int i, int heapSize);
};

int main(int argc, char *argv[])
{
    PriorityQueue Q;
    Q.INSERT(3);
    Q.INSERT(2);

    Q.EXTRACT_MIN();

    int x = Q.MINIMUM();
    cout << x << endl;
    return 0;
}

void PriorityQueue::INSERT(int key) /// 插入元素具体实现
{
    heapSize++;
    A[heapSize] = MAX;

    INCREASE_KEY(heapSize,key);
}

void PriorityQueue::INCREASE_KEY(int i,int key) /// 将元素x的关键字值增加到k具体实现
{
    if(key > A[i])
        cout << "Error!" << endl;
    A[i] = key;

    while(i > 1 && A[i] < A[i / 2]) /// 较大的数下沉
    {
        swap(A[i], A[i/2]);
        i = i/2;
    }
}

int PriorityQueue::MINIMUM() /// 返回具有最小关键字的元素具体实现
{
    return A[1];
}

/* 为了便于重建堆，
** 实际的操作是将最后一个数据的值赋给根结点，
** 然后再从根结点开始进行一次从上向下的调整。
*/

void PriorityQueue::MIN_HEAPIFY(int i, int heapSize) /// 调整小顶堆
{
    int l = 2 * i;
    int r = 2 * i + 1;

    /*调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点*/
    int minimum;

    if(l <= heapSize && A[l] < A[i])
    {
        minimum = l;
    }
    else
    {
        minimum = i;
    }
    if(r <= heapSize && A[r] > A[minimum])
    {
        minimum = r;
    }
    if(minimum != i)
    {
        swap(A[i], A[heapSize]);
        MIN_HEAPIFY(minimum, heapSize);
    }
}
void PriorityQueue::EXTRACT_MIN() /// 去掉并且返回具有最小关键字的元素具体实现
{
    if(heapSize < 1)
        cout << "Error!" << endl;

//    int min = A[1];
    cout << A[1] << endl;
    A[1] = A[heapSize];

    heapSize--;

    MIN_HEAPIFY(1, heapSize); /// 调整
}