寻求最小的K个数（利用堆实现）

常见的一个问题，寻求最小的K个数，或者top K问题。利用构建最大堆，可以在O(k+(n-k)logk) = O(n*logK)时间内实现。
顺便再来复习一下最大堆。

    package 最大堆;

public class MaxPQ <Key extends Comparable<Key>>{
    private Key[] pq;
    private int N = 0;

    public MaxPQ(int maxN){
        //存储于1-N中
        pq = (Key[])new Comparable[maxN+1]; 
    }
    private boolean less(int i,int j){
        //堆中实现比较的方法,i位置比j位置小，返回值为true
        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;
    }
    private void swim(int k){//当插入一个元素时，会调用此方法，上浮
        while(k > 1 && less(k/2,k)){
            exch(k/2,k);
            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))  //如果k位置的不小于他的子节点，停止下沉
                break;
            exch(k,j);
            k = j;
        }
    }

    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;
    }

}

上面的代码较为完整地实现了一个最大堆所需要的方法。
这样，我们只要维护一个K个元素的最大堆，然后对n-k个元素和max比较，如果小则插入该元素，否则堆不变。