數據結構與算法（五），優先隊列

這節總結一下優先隊列的經常使用實現方法。

一、基本概念

普通的隊列是一種先進先出的數據結構，元素在隊列尾追加，而從隊列頭刪除。在優先隊列中，元素被賦予優先級。當訪問元素時，具備最高優先級的元素最早刪除。優先隊列具備最高級先出 （largest-in，first-out）的行爲特徵。(百度百科)

抽象數據類型：

優先隊列的接口同前面講到的隊列的接口同樣，是其基於泛型的API接口代碼以下：

public interface Queue<E> {

    //隊列是否爲空
    boolean isEmpty();

    //隊列的大小
    int size();

    //入隊
    void enQueue(E element);

    //出隊
    E deQueue();
}

二、基於數組實現的優先隊列

實現優先隊列最簡的方法就是基於前面講到的基於數組的棧的代碼，只需對插入或刪除操做做相應的更改便可。

2.一、基於有序數組的實現

在棧的代碼的插入方法中添加代碼，將全部較大的元素向右移動一格，以保證數組有序（和插入排序相同），這裏咱們可使用二分查找的方法來找出元素應插入的位置，而後再移動元素。這樣最大元素，老是在數組的最右邊，其刪除操做和棧的實現中同樣。

代碼：

/**
 * 基於有序數組的實現的優先隊列
 * @author Alent
 * @param <E>
 */
public class PriorityQueue<E extends Comparable<E>> implements Queue<E>{
    private E[] elements;
    private int size=0;
    
    @SuppressWarnings("unchecked")
    public PriorityQueue() {
        elements = (E[])new Comparable[1]; 
    }
    
    @Override public int size() {return size;}

    @Override public boolean isEmpty() {return size == 0;}

    @Override
    public void enQueue(E element) {
        if(size == elements.length) {
            resizingArray(2*size);//若數組已滿將長度加倍
        }
        elements[size++] = element;
        insertSort(elements);
    }

    @Override
    public E deQueue() {
        E element = elements[--size];
        elements[size] = null;     //注意：避免對象遊離
        if(size > 0 && size == elements.length/4) {
            resizingArray(elements.length/2);//小於數組1/4,將數組減半
        }
        return element;
    }
    
    //插入排序，因爲前面n-1個元素是有序的，這裏只插入最後一個元素
    public void insertSort(E[] a) {
        int N = size -1; //最後一個元素是size-1，不是a.length-1
        if(N == 0) return;
        int num = binaryFind(a, a[N], 0, N-1);
        E temp = a[N];
        //num後的元素向後移動
        for (int j = N; j > num; j--) {
           a[j] = a[j-1];
        }
        a[num] = temp;
    }

    //找出元素應在數組中插入的位置
    public int binaryFind(E[] a, E temp, int down, int up) {
        if(up<down || up>a.length || down<0) {
            System.out.println("下標錯誤");
        }
        if(temp.compareTo(a[down]) < 0) return down;
        if(temp.compareTo(a[up]) > 0) return up+1;
        int mid = (up-down)/2 + down;
        if(temp.compareTo(a[mid]) == 0) {
            return mid + 1;
        }else if(temp.compareTo(a[mid])<0) {
            up = mid-1;
        }else if(temp.compareTo(a[mid])>0) {
            down = mid+1;
        }
        return binaryFind(a,temp,down,up);
    }

    //交換兩個元素
    public void swap(E[] a,int i,int j) {
        E temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    
    //調整數組大小
    public void resizingArray(int num) {
        @SuppressWarnings("unchecked")
        E[] temp = (E[])new Comparable[num];
        for(int i=0;i<size;i++) {
            temp[i] = elements[i];
        }
        elements = temp;
    }
    
    public static void main(String[] args) {
        int[] a = {4,2,1,3,8,new Integer(5),7,6};//測試數組
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
        System.out.print("入棧順序：");
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");
            pq.enQueue(a[i]);
        }
        System.out.println();
        System.out.print("出棧順序數組實現：");
        while(!pq.isEmpty()) {
            System.out.println(pq.deQueue());
        }
    }
}

2.二、基於無序數組的實現

一樣，咱們一個能夠在刪除方法中修改，在刪除方法中添加一段相似於選擇排序內循環的代碼，每次刪除時先找出數組中的最大元素，而後與最右邊元素進行交換，而後在刪除元素。

代碼：

@Override
public void enQueue(E element) {
    if(size == elements.length) {
        resizingArray(2*size);//若數組已滿將長度加倍
    }
    elements[size++] = element;
}

@Override
public E deQueue() {
    swapMax(elements);
    E element = elements[--size];
    elements[size] = null;     //注意：避免對象遊離
    if(size > 0 && size == elements.length/4) {
        resizingArray(elements.length/2);//小於數組1/4,將數組減半
    }
    return element;
}

public void swapMax(E[] a) {
    int max = size -1;
    for(int i=0;i<size-1; i++) {
        if(larger(a[i],a[max])) 
            max = i;
    }
    swap(a, size-1, max);
}

//比較兩個元素大小
public boolean larger(E a1, E a2) {
    return a1.compareTo(a2)>0;
}

三、基於堆實現的優先隊列

基本概念：

當一個二叉樹的每一個結點都大於等於它的兩個子結點時，咱們稱它是堆有序的。根結點是堆有序的二叉樹的最大結點。

二叉堆是一組可以用堆有序的徹底二叉樹排序的元素，並在數組中按照層級存儲。

一棵堆有序的徹底二叉樹

爲了操做方便，這是咱們使用一個數組，來表示一個堆。咱們不使用數組的第一個元素，具體實如今《數據結構與算法（四），樹》中有說起，這裏就不說了。

3.一、堆的有序化

當咱們將元素插入到堆（數組的末尾）中時，插入的元素可能比它的父結點要大，堆的有序狀態被打破。咱們須要交換它和它的父節點來修堆，直到堆從新變爲有序狀態。其操做以下圖：

代碼以下：

//上浮操做
private void swim(int k) {
        while(k > 1 && less(k/2, k)) {
            swap(k/2, k);
            k = k/2;
        }
    }

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

//交換兩個元素
public void swap(int i,int j) {
    E temp = elements[i];
    elements[i] = elements[j];
    elements[j] = temp;
}

一樣的，當咱們從堆中刪除根結點並將它的最後一個元素放到頂端時，堆的有序性被打破，咱們須要將它與它的兩個子結點種的較大者進行交換，以恢復堆的有序性，其操做流程以下圖：

其代碼以下：

//下沉操做
private void sink(int k) {
    while(2*k <= size) {
        int j = 2*k;
        if(j < size && less(j, j+1))
            j++;
        if(!less(k,j))
            break;
        swap(k,j);
        k = j;
    }
}

3.二、基於堆實現的優先隊列

基於堆的優先隊列的實現代碼以下：

/**
 * 基於堆的優先隊列
 * @author Alent
 */
public class MaxPQ<E extends Comparable<E>> implements Queue<E>{
    private E[] elements;
    private int size=0;
    
    @SuppressWarnings("unchecked")
    public MaxPQ(int capacity) {
        elements = (E[])new Comparable[capacity + 1]; 
    }
    
    @Override public int size() {return size;}

    @Override public boolean isEmpty() {return size == 0;}

    @Override
    public void enQueue(E element) {
        elements[++size] = element;
        swim(size);
    }
    
    //上浮
    private void swim(int k) {
        while(k > 1 && less(k/2, k)) {
            swap(k/2, k);
            k = k/2;
        }
    }
    
    private boolean less(int i, int j) {
        return elements[i].compareTo(elements[j]) < 0;
    }

    @Override
    public E deQueue() {
        E result = elements[1];
        swap(1, size--);
        elements[size + 1] = null;
        sink(1);
        return result;
    }
    
    //下沉
    private void sink(int k) {
        while(2*k <= size) {
            int j = 2*k;
            if(j < size && less(j, j+1))
                j++;
            if(!less(k,j))
                break;
            swap(k,j);
            k = j;
        }
    }

    //交換兩個元素
    public void swap(int i,int j) {
        E temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }
}

三種實現方法的時間複雜度比較：

四、索引優先隊列

索引優先隊列，它用一個索引數組保存了某個元素在優先隊列中的位置，使得咱們可以引用已經進入優先隊列中的元素。最在些應用中，一般是頗有必要的，如：有向圖的Dijkstra算法中就使用了索引優先隊列，來返回最小邊的索引。

其實現方法爲：

使用elements[]數組來保存隊列中的元素，pq[]數組用來保存elements中元素的索引，在添加一個數組qp[]來保存pq[]的逆序——qp[i]的值是i在pq[]中的位置（即 pq[qp[i]] = i）。若i不在隊列中，則令qp[i] = -1。輔助函數less()、swap()、sink()、swim()和前面優先隊列中的同樣。

索引優先隊列的代碼實現：

/**
 * 基於堆實現的索引優先隊列
 */
public class IndexMinPQ<E extends Comparable<E>>{

    private int[] pq; //索引二叉堆
    private int[] qp; // 保存逆序：pq[qp[i]] = i;
    private E[] elements; //元素
    private int size = 0;

    @SuppressWarnings("unchecked")
    public IndexMinPQ(int capacity) {
        elements = (E[]) new Comparable[capacity + 1];
        pq = new int[capacity + 1];
        qp = new int[capacity + 1];
        for (int i = 0; i <= capacity; i++) {
            qp[i] = -1;
        }
    }

    public boolean isEmpty() {
        return size == 0;
    }
    //刪除最小元素，並返回索引
    public int delMin() {
        int index = pq[1];
        swap(1, size--);
        sink(1);
        elements[pq[size + 1]] = null;
        qp[pq[size + 1]] = -1;
        return index;
    }
    //刪除索引k及其元素
    public void delete(int k) {
        int index = qp[k];
        swap(index, size--);
        swim(index);
        sink(index);
        elements[k] = null;
        qp[k] = -1;
    }
    
    //插入元素，將它和索引k關聯
    public void insert(int k, E element) {
        size++;
        qp[k] = size;
        pq[size] = k;
        elements[k] = element;
        swim(size);
    }

     //改變索引k關聯的元素
    public void change(int k, E element) {
        elements[k] = element;
        swim(qp[k]);
        sink(qp[k]);
    }
    
    //是否包含索引k
    public boolean contains(int k) {
        return qp[k] != -1;
    }
    
    //下沉
    private void sink(int k) {
        while (2 * k <= size) {
            int j = 2 * k;
            if (j < size && less(j, j + 1))
                j++;
            if (!less(k, j))
                break;
            swap(k, j);
            k = j;
        }
    }

    //上浮
    private void swim(int k) {
        while (k > 1 && less(k / 2, k)) {
            swap(k, k / 2);
            k = k / 2;
        }
    }
    private boolean less(int i, int j) {
        return elements[pq[i]].compareTo(elements[pq[j]]) > 0;
    }

    //交換兩元素
    private void swap(int i, int j) {
        int swap = pq[i];
        pq[i] = pq[j];
        pq[j] = swap;
        qp[pq[i]] = i;
        qp[pq[j]] = j;
    }
}

索引優先隊列的時間複雜度：

找出最大元素的索引優先隊列的JAVA版本IndexMaxPQ.java 點這裏。

好了，這節就總結這麼多吧。