深刻理解Java PriorityQueue

參考http://www.javashuo.com/article/p-qzjgotve-dc.html

PriorityQueue

Java中PriorityQueue經過二叉小頂堆實現，能夠用一棵徹底二叉樹表示。本文從Queue接口函數出發，結合生動的圖解，深刻淺出地分析PriorityQueue每一個操做的具體過程和時間複雜度，將讓讀者創建對PriorityQueue創建清晰而深刻的認識。

整體介紹

前面以Java ArrayDeque爲例講解了Stack和Queue，其實還有一種特殊的隊列叫作PriorityQueue，即優先隊列。優先隊列的做用是能保證每次取出的元素都是隊列中權值最小的（Java的優先隊列每次取最小元素，C++的優先隊列每次取最大元素）。這裏牽涉到了大小關係，元素大小的評判能夠經過元素自己的天然順序（natural ordering），也能夠經過構造時傳入的比較器（Comparator，相似於C++的仿函數）。

Java中PriorityQueue實現了Queue接口，不容許放入null元素；其經過堆實現，具體說是經過徹底二叉樹（complete binary tree）實現的小頂堆（任意一個非葉子節點的權值，都不大於其左右子節點的權值），也就意味着能夠經過數組來做爲PriorityQueue的底層實現。

上圖中咱們給每一個元素按照層序遍歷的方式進行了編號，若是你足夠細心，會發現父節點和子節點的編號是有聯繫的，更確切的說父子節點的編號之間有以下關係：

leftNo = parentNo*2+1

rightNo = parentNo*2+2

parentNo = (nodeNo-1)/2

經過上述三個公式，能夠輕易計算出某個節點的父節點以及子節點的下標。這也就是爲何能夠直接用數組來存儲堆的緣由。

PriorityQueue的peek()和element操做是常數時間，add(), offer(), 無參數的remove()以及poll()方法的時間複雜度都是log(N)。

方法剖析

add()和offer()

add(E e)和offer(E e)的語義相同，都是向優先隊列中插入元素，只是Queue接口規定兩者對插入失敗時的處理不一樣，前者在插入失敗時拋出異常，後則則會返回false。對於PriorityQueue這兩個方法其實沒什麼差異。

新加入的元素可能會破壞小頂堆的性質，所以須要進行必要的調整。

//offer(E e)
public boolean offer(E e) {
    if (e == null)//不容許放入null元素
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);//自動擴容
    size = i + 1;
    if (i == 0)//隊列原來爲空，這是插入的第一個元素
        queue[0] = e;
    else
        siftUp(i, e);//調整
    return true;
}

上述代碼中，擴容函數grow()相似於ArrayList裏的grow()函數，就是再申請一個更大的數組，並將原數組的元素複製過去，這裏再也不贅述。須要注意的是siftUp(int k, E x)方法，該方法用於插入元素x並維持堆的特性。

//siftUp()
private void siftUp(int k, E x) {
    while (k > 0) {
        int parent = (k - 1) >>> 1;//parentNo = (nodeNo-1)/2
        Object e = queue[parent];
        if (comparator.compare(x, (E) e) >= 0)//調用比較器的比較方法
            break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = x;
}

新加入的元素x可能會破壞小頂堆的性質，所以須要進行調整。調整的過程爲：從k指定的位置開始，將x逐層與當前點的parent進行比較並交換，直到知足x >= queue[parent]爲止。注意這裏的比較能夠是元素的天然順序，也能夠是依靠比較器的順序。

element()和peek()

element()和peek()的語義徹底相同，都是獲取但不刪除隊首元素，也就是隊列中權值最小的那個元素，兩者惟一的區別是當方法失敗時前者拋出異常，後者返回null。根據小頂堆的性質，堆頂那個元素就是全局最小的那個；因爲堆用數組表示，根據下標關係，0下標處的那個元素既是堆頂元素。因此直接返回數組0下標處的那個元素便可。

代碼也就很是簡潔：

//peek()
public E peek() {
    if (size == 0)
        return null;
    return (E) queue[0];//0下標處的那個元素就是最小的那個
}

remove()和poll()

remove()和poll()方法的語義也徹底相同，都是獲取並刪除隊首元素，區別是當方法失敗時前者拋出異常，後者返回null。因爲刪除操做會改變隊列的結構，爲維護小頂堆的性質，須要進行必要的調整。

代碼以下：

public E poll() {
    if (size == 0)
        return null;
    int s = --size;
    modCount++;
    E result = (E) queue[0];//0下標處的那個元素就是最小的那個
    E x = (E) queue[s];
    queue[s] = null;
    if (s != 0)
        siftDown(0, x);//調整
    return result;
}

上述代碼首先記錄0下標處的元素，並用最後一個元素替換0下標位置的元素，以後調用siftDown()方法對堆進行調整，最後返回原來0下標處的那個元素（也就是最小的那個元素）。重點是siftDown(int k, E x)方法，該方法的做用是從k指定的位置開始，將x逐層向下與當前點的左右孩子中較小的那個交換，直到x小於或等於左右孩子中的任何一個爲止。

//siftDown()
private void siftDown(int k, E x) {
    int half = size >>> 1;
    while (k < half) {
        //首先找到左右孩子中較小的那個，記錄到c裏，並用child記錄其下標
        int child = (k << 1) + 1;//leftNo = parentNo*2+1
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
            comparator.compare((E) c, (E) queue[right]) > 0)
            c = queue[child = right];
        if (comparator.compare(x, (E) c) <= 0)
            break;
        queue[k] = c;//而後用c取代原來的值
        k = child;
    }
    queue[k] = x;
}

remove(Object o)

remove(Object o)方法用於刪除隊列中跟o相等的某一個元素（若是有多個相等，只刪除一個），該方法不是Queue接口內的方法，而是Collection接口的方法。因爲刪除操做會改變隊列結構，因此要進行調整；又因爲刪除元素的位置多是任意的，因此調整過程比其它函數稍加繁瑣。具體來講，remove(Object o)能夠分爲2種狀況：1. 刪除的是最後一個元素。直接刪除便可，不須要調整。2. 刪除的不是最後一個元素，從刪除點開始以最後一個元素爲參照調用一次siftDown()便可。此處再也不贅述。

具體代碼以下：

//remove(Object o)
public boolean remove(Object o) {
    //經過遍歷數組的方式找到第一個知足o.equals(queue[i])元素的下標
    int i = indexOf(o);
    if (i == -1)
        return false;
    int s = --size;
    if (s == i) //狀況1
        queue[i] = null;
    else {
        E moved = (E) queue[s];
        queue[s] = null;
        siftDown(i, moved);//狀況2
        ......
    }
    return true;
}

使用PriorityQueue實現大頂堆

PriorityQueue默認是一個小頂堆，然而能夠經過傳入自定義的Comparator函數來實現大頂堆。以下代碼：

private static final int DEFAULT_INITIAL_CAPACITY = 11;
PriorityQueue<Integer> maxHeap=new PriorityQueue<Integer>(DEFAULT_INITIAL_CAPACITY, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {                
            return o2-o1;
        }
    });