優先隊列

定義

普通的隊列是一種先進先出的數據結構，元素在隊列尾追加，而從隊列頭刪除。在優先隊列中，元素被賦予優先級。當訪問元素時，具有最高優先級的元素最先刪除。優先隊列具有最高級先出 （first in, largest out）的行爲特徵。通常採用堆數據結構來實現。

堆的定義

數據結構二叉堆能夠很好地實現優先隊列的基本操作。在二叉堆的數組中，每個元素都要保證大於等於另兩個特定位置的元素。相應地，這些位置的元素又至少要大於等於數組中的另兩個元素。

當一顆二叉樹的每個結點都大於等於它的兩個子結點時，它被稱爲堆有序。

基於堆的優先隊列

public class MaxPQ<Key extends Comparable<Key>> {
    private Key[] pq;   //儲存於pq[1..N]中，pq[0]沒有使用
    private int N = 0;

    public MaxPQ(int maxN){
        pq = (Key[]) new Comparable[maxN + 1];
    }


    public boolean isEmpty(){
        return N == 0;
    }

    public int size(){
        return N;
    }

    public void insert(Key v){
        pq[++N] = v;
        swim(N);
    }

    public Key delMax(){
        Key max = pq[1];
        exch(1, N--);
        pq[N + 1] = null;
        sink(1);
        return max;
    }

    private void swim(int k){
        while(k / 2 > 0 && less(k / 2, k)){
            exch(k / 2, k);
            k /= 2;
        }
    }

    private void sink(int k){
        while(k * 2 <= N){
            int j = k * 2;
            if(less(j, j + 1)){
                j++;
            }
            if(!less(k, j)){
                break;
            }
            exch(k, j);
            k = j;
        }


    }

    private boolean less(int i, int j){
        return pq[i].compareTo(pq[j]) < 0;
    }

    private void exch(int i, int j){
        Key t = pq[i];
        pq[i] = pq[j];
        pq[j] = t;
    }

}

堆排序

    我們可以把任意的優先隊列變成一種排序方法。將所有元素插入一個查找最小元素的優先隊列，然後再重複調用刪除最小元素的操作來將它們按順序刪除。

public class Multiway {

    public static int N;

    public static void sort(Comparable[] a){
        N = a.length;
        //堆的創建過程
        for(int i = N / 2;i >= 1;i--){//N / 2對應的是由子結點的那個結點。
            sink(a, i);
        }
        //刪除最大的結點
        while(N > 1){
            Example.exch(a, 1, N--);
            sink(a,1);
        }
    }

    private static void sink(Comparable[] a, int k){

        while(2 * k <= N){
            int j = 2 * k;
            if(j < N && a[j].compareTo(a[j + 1]) < 0){
                j++;
            }
            if(a[k].compareTo(a[j]) > 0){
                break;
            }
            Example.exch(a, j, k);
            k = j;
        }
    }

}