算法：基于堆优先级队列

优先级队列的定义应用场景非常广泛，因为很多时候我们需要处理有序的元素，但是不一定要求全部的元素排序，这时候优先级队列就很适合。基于堆的优先级队列能高效的实现插入和删除操作，下面给出基于数组和堆的优先级队列。

基于堆优先级队列

public class MaxPQ <K extends Comparable<K>> {

    private K[] pq;
    private int N = 0;

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

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

    public int size(){
        return N;
    }

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

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

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

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

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

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

    public static void main(String[]args){
        MaxPQ maxPQ = new MaxPQ(10);
        maxPQ.insert(1);
        maxPQ.insert(12);
        maxPQ.insert(10);
        maxPQ.insert(3);
        maxPQ.insert(32);

        while (!maxPQ.isEmpty()){
            System.out.println(maxPQ.delMax());
        }
    }
}