算法入門：優先隊列實現——堆

定義

優先隊列（PriorityQueue），根據key值的大小將元素進行排序、先被pop的通常是優先級最高的。此處介紹基於堆實現的優先隊列，binary heap是一種完全二叉樹，以大堆爲例，每棵樹的根節點的key值一定大於其子孫節點的key值，完全二叉樹除了最底層的葉子節點外，其他位置都是填滿的。這樣我們可以利用數組來存儲所有節點。

若將數組從下標1開始存儲元素、那麼下標爲 i 的節點的左孩子節點的下標爲 2 * i、而右孩子節點下標爲 2 * i + 1;這樣可以很容易定位一個節點的孩子節點或父節點的在數組中位置。

 

插入數據

1. 添加元素，也就是需要將元素添加到最底層葉子節點從左向右的空位置上。就是vector的最後一個位置。
2. 通過下標計算出新節點的父親節點、與父節點key值比較、若比父節點大、則與父節點進行位置交換、不斷上溯直到比父節點小或者父節點爲空（也就是本身成爲了根節點）。
3. 在與父節點交換時、只需要交換他們的值就好。

• 插入一個111，首先把111 插入到底部

• 調整堆，把111 和 111的頂部parentNode進行比較，發現111大於33，所有需要改變exchange 111 和 33的位置

• 接着111 和 parentNode比，發現還是大於ParentNode，所以繼續改變位置。

• 繼續比較

• 到達top了，沒有元素比111大了。此時堆變得有序了。

刪除數據

1. 因爲是隊列、每次pop是刪除都是刪除根節點。
2. 由於要保證heap的complete binary tree結構、每次刪除的節點實際上都是最後一塊內存空間（vector中最後一個位置）。
3. 刪除根節點時需要比較左右節點的key值、與刪除節點進行交換，然後以刪除節點位置開始向下查找（重複）。

• 首先我們先把111和 最底部的元素交換位置，並且取出111。

​​​​​​​

• 把top部的元素和2個子元素比較大小，如果比子元素小的話，需要交換他們的位置，把33 和 Math.max（100， 50）交換位置。

​​​​​​​

• 33 比 90 小，交換他們的位置

#include <iostream>
#include <vector>
using namespace std;

template<typename T>
class PriorityQueue {
    private:
        // 在heap內部維護一個數組vector用來保存元素、方便建立堆和節點的添加刪除
        vector<T> v;
        int size;
        const static int initCap = 100;
    private:
        int parent(int pos) {
            return pos/2;
        }

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

        int right(int pos) {
            return pos*2 + 1;
        }
    public:
        PriorityQueue():
            size(0) {
                v = vector<T>(initCap);
            }

        bool enQueue(const T& t) {
            size++;
            v[size] = t;
            int i = size;
            //插入到尾部，一直上提到使當前堆符合最大堆性質爲止
            while(i > 1 && v[i] > v[parent(i)]) {
                T tmp = v[i];
                v[i] = v[parent(i)];
                v[parent(i)] = tmp;
                i = parent(i);
            }
            return true;
        }

        bool deQueue(T& max) {
            //取出最大值，並把尾部元素和最大值交換，然後維護當前堆到符合堆性質
            if(size < 1) {
                return false;
            }
            max = v[1];
            v[1] = v[size];
            v[size] = max;
            size--;
            maxHeapIfy(1);
            return true;
        }

        void maxHeapIfy(int pos) {
            int largestPos = pos;
            if(left(pos) <= size && v[pos] < v[left(pos)]) {
                largestPos = left(pos);
            }
            if(right(pos) <= size && v[largestPos] < v[right(pos)]) {
                largestPos = right(pos);
            }
            if(largestPos != pos) {
                T tmp = v[pos];
                v[pos] = v[largestPos];
                v[largestPos] = tmp;
                maxHeapIfy(largestPos);
            }
        }

        int getSize() {
            return size;
        }

        bool top(T& t) {
            if(size < 1) {
                return false;
            }
            t = v[1];
            return true;
        }
};

int main() {
    PriorityQueue<int> pQ;
    pQ.enQueue(8);
    pQ.enQueue(1);
    pQ.enQueue(3);
    pQ.enQueue(6);
    pQ.enQueue(5);
    pQ.enQueue(3);
    pQ.enQueue(10);
    pQ.enQueue(9);
    pQ.enQueue(7);
    int a = -1;
    while(pQ.deQueue(a)) {
        cout<<a<<" ";
    }
    cout<<endl;
    return 0;
}