最大堆的实现和运用

最近看到了这样一个题目：输入N（很大）个整数，找出其中最小的K个数。

初看这个问题，很多人下意识的的思路就是先排序，再找出最大的数，这种做法当然可行，空间复杂度为O(n)，时间复杂度为O(NlogN），在海量数据的情况下会消耗较大内存；此处采用最大堆，则可以提高效率。

最大堆是一种数据结构，本质上是一颗完全二叉树，树的根节点是最大值，与此对应有最小堆：我们可以创建一个容量为K的最大堆，先插入K个数据，然后再插入剩余数据，若此时插入的数字大于堆的根节点值，证明该数不可能是最小的K个数，若插入的值小于堆节点的根节点值，则用这个数替换已有的最大值，堆内会自动维护在根节点生成新的最大值。

下面以java为例基于数组实现最大堆结构

package Heap;
//基于数组的最大堆
public class MaxPQ<Key extends Comparable<Key>> {
    private Key[] pq;
    private int N=0;
    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);
    }
    //删除返回最大值
    public Key delMax(){
        Key max=pq[1];
        exch(1,N--);
        pq[N+1]=null;
        sink(1);
        return max;
    }

    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)){
                break;
            }
            exch(k,j);
            k=j;
        }
    }

    private boolean less(int i,int j){
        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;
    }
}

当然，java集合已经为我们实现了这个数据结构，PriorityQueue默认为一个最小堆，我们也可以自定义排序方式：

Queue<Integer> pq=new PriorityQueue<>(11,
            new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2-o1;
                }
            });

到这文章开头的问题使用最大堆就非常容易解决了，而且具有不错的效率。