优先队列和堆排序

1. 优先队列

优先队列支持的两种操作：删除最大（小）元素，插入元素。和队列以及栈类似。

可以将优先队列比作一个黑盒：里面存放最大（小）的若干元素，支持向里面添加元素，取出删除最大（小）元素。

jdk自带实现：PriorityQueue.

jdk还有双向顺序队列ArrayDeque和双向链式队列LinkedList。

实现方法：

　　1).数组无序实现：insert()方法和栈的push()方法一样，删除最大元素可以内循环找出最大元素然后和边界元素交换删除。

　　2).数组有序实现：插入时保持数组有序，删除时直接删除边界元素。

　　3).链表实现。

　　4).堆实现。

　　比较：

数据结构	插入元素	删除元素
有序数组	N	1
无序数组	1	N
堆	logN	logN
理想情况	1	1

2.堆

用完全二叉树来表示堆，用数组即可实现。为方便表示不使用数组第一个位置，根节点在位置1，设一节点在位置k，则它的子节点在2k和2k+1，父节点在k/2。

堆里面最重要的操作就是要保证堆有序的两个操作：上浮swim()和下沉sink()。上浮是以此节点开始，比较它和父节点的值，若不满足堆，则交换位置，直到根节点。下沉类似：和其子节点比较，不满足堆则交换，直到到达堆的底部。

插入操作：将新元素放到数组末尾，增加堆的大小并上浮新元素到合适位置。

删除最大（小）元素：从数组顶端删除最大（小）元素，并将数组最后一个元素放到顶端，减小堆大小，下沉该元素到合适位置。

用堆实现的优先队列：

//优先队列，用堆实现
//可以向队列插入数据，并删除最大的数，插入删除的的复杂度都是logN
public class MaxPQ <Key extends Comparable<Key>>{
    private Key[] pq;
    private int N = 0;
    
    @SuppressWarnings("unchecked")
    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);
    }
    private void swim(int n) {
        while(n > 1 && less(n/2,n)){
            exch(n/2,n);
            n = n/2;
        }
    }

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

    public Key delMax(){
        Key max = pq[1];
        exch(1,N--);
        pq[N=1] = null;        //防止对象游离
        sink(1);
        return max;
    }

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

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

 3.索引优先队列

它允许用例引用优先队列中的元素，方法是给每个元素一个索引。

//索引优先队列，保存索引及其对应的项
//用堆实现，复杂度为logN;
public class IndexMinPQ<Item extends Comparable<Item>> {
    private int[] pq;    //保存索引
    private int[] qp;    //保存索引所对应堆中的下标
    private Item[] items;  //保存项
    private int N = 0;
    
    public IndexMinPQ(int maxN) {
        pq = new int[maxN + 1];   //数组[0]未使用
        qp = new int[maxN + 1];
        items = (Item[]) new Comparable[maxN + 1];
        for(int i = 0; i <= maxN; i++) qp[i] = -1;
    }
    public void insert(int k, Item item){
        N++;
        pq[N] = k;
        qp[k] = N;
        items[k] = item;
        swim(N);
    }
    private void swim(int n) {
        while(n > 1 && less(n, n/2)){
            exch(n,n/2);
            n = n/2;
        }
    }
    private void exch(int i, int j) {
        int t = pq[i];
        pq[i] = pq[j];
        pq[j] = t;
        qp[pq[i]] = i;
        qp[pq[j]] = j;
    }
    private boolean less(int i, int j) {
        return items[pq[i]].compareTo(items[pq[j]]) < 0;
    }
    public void change(int k, Item item){
        items[k] = item;
        swim(qp[k]);
        sink(qp[k]);
    }
    private void sink(int i) {
        while(2*i <= N){
            int j = 2*i;
            if(j < N && less(j+1,j)) j++;
            if(less(i,j)) break;
            exch(i,j);
            i = j;
        }
    }
    public boolean contains(int k){
        return qp[k] != -1;    
    }
    //删除索引为k的项
    public void delete(int k){
        int index = qp[k];
        exch(index, N--);
        swim(index);
        sink(index);
        qp[N+1] = -1;
        items[pq[N+1]] = null;
    }
    public Item min(){
        return items[pq[1]];
    }
    public int minIndex(){
        return pq[1];
    }
    //删除最小项，并返回它的索引
    public int delMin(){
        int minIndex = pq[1];
        exch(1,N--);
        sink(1);
        qp[N+1] = -1;
        items[pq[N+1]] = null;
        return minIndex;
    }
    public boolean isEmpty(){
        return N == 0;
    }
    public int size(){
        return N;
    }
}

4.堆排序

堆排序可以分为两个阶段:堆的构造阶段和下沉排序阶段。每次循环都将堆顶元素和最后一个交换，最后即为有序的。构造阶段的高效方法是从N/2开始，从右至左用sink()构造子堆。跳过大小为1的子堆。

下面的实现，我使用了数组的0下标，因为如果不使用0下标，在堆排序后还要用一层循环来给0号元素排序，麻烦。虽然这样在堆实现上有点麻烦。

public class HeapSort {
    public static void main(String[] args) {
        String[] a = new String[]{"G","F","E","D","C","B","A","H","I","J","K"};
        heapSort(a);
        for(int i = 0; i < a.length; i++)
            System.out.print(a[i]);
    }
    public static void heapSort(Comparable a[]){
        int N = a.length-1;
        for(int i = (N-1)/2; i >= 0; i--){
            sink(a,i,N);
        }
        while(N > 0){
            exch(a,0,N--);
            sink(a,0,N);
        }
    }
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    private static void sink(Comparable[] a, int i, int N) {
        while(2*i+1 <= N){
            int j = 2*i+1;
            if(j < N && a[j].compareTo(a[j+1]) < 0) j++;
            if(a[i].compareTo(a[j])> 0) break;
            exch(a,i,j);
            i = j;
        }
    }
}

 补充：

Java系统库中的优先队列：java.util.PriorityQueue.

该优先队列对基本数据类型默认使用自然顺序，即MinPq，小顶堆。可以在构造器中使用指定的比较器来使其成为MaxPQ。

相关方法：add;peek;poll;remove;clear;size;contains;toArray  等等。

不允许使用null元素。

默认构造器的初始容量为11.

内部实现：使用数组，对元素采用的是堆排序。