求N个数中前k个大的数

解题思路：一般思路就是将N个数排序后，取前k个数就ok。但是如果N个数是几十亿个数，加载不到内存怎么办？这时候就需要利用堆来解决这个问题

具体的思路是：先建一个k个数的小堆，然后从k+1个数往后的值与堆顶元素比较，若此数比堆顶元素大，就将堆顶元素用这个数替换，然后重新调整堆，以此向后重复上述过程，直到将N个数比较完成，那么此时组成这个堆的k个元素就是前k个大的数。

接下来我们讲一下最小堆与最大对堆的思想：

一、堆树的定义

堆树的定义如下：

（1）堆树是一颗完全二叉树；

（2）堆树中某个节点的值总是不大于或不小于其孩子节点的值；

（3）堆树中每个节点的子树都是堆树。

当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。如下图所示，上面的为最大堆，下面的为最小堆。

二、堆树的操作

以最大堆为例进行讲解，最小堆同理。

原始数据为a[] = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7}，采用顺序存储方式，对应的完全二叉树如下图所示：

（1）构造最大堆

在构造堆的基本思想就是：首先将每个叶子节点视为一个堆，再将每个叶子节点与其父节点一起构造成一个包含更多节点的对。

所以，在构造堆的时候，首先需要找到最后一个节点的父节点，从这个节点开始构造最大堆；直到该节点前面所有分支节点都处理完毕，这样最大堆就构造完毕了。

假设树的节点个数为n，以1为下标开始编号，直到n结束。对于节点i，其父节点为i/2；左孩子节点为i*2，右孩子节点为i*2+1。最后一个节点的下标为n，其父节点的下标为n/2。

如下图所示，最后一个节点为7，其父节点为16，从16这个节点开始构造最大堆；构造完毕之后，转移到下一个父节点2，直到所有父节点都构造完毕。

最后根据 最大值堆的思想，贴出一份最大堆的实现代码：

public class MaxHeap {

private int []heap ;
private int currentSize;
private static int MAXSIZE ;

public MaxHeap(int n){
    heap=new int[n];
    currentSize=0;
    MAXSIZE=n;
}

public boolean insert(int x){
    if(currentSize==MAXSIZE){
        System.out.println("Sorry,this heap is full!");
        return false;
    }
    //如果堆不满的话
    currentSize++;
    int flag=currentSize-1;
    while(flag>0){
        int parent=(flag-1)/2;
        if(heap[parent]>x){
            heap[flag]=x;
            return true;
        }else{
            heap[flag]=heap[parent];
            flag=parent;
        }
    }
    heap[0]=x;
    return true;
}

public void siftDown(int flag){
    int want=flag;
    int x=heap[flag];

    while(want<currentSize){
        int lChild=2*want+1;
        int rChild=2*want+2;
        int MAXChildNumber;
        if(lChild>currentSize){  //没有孩子节点
            heap[want]=x;
        }else{                   //有两个孩子节点
            if(lChild<currentSize){
                MAXChildNumber=heap[lChild]>heap[rChild]?lChild:rChild;
            }else{
                MAXChildNumber=lChild;
            }
            if(heap[MAXChildNumber]<x){
                heap[want]=x;return;
            }else{
                heap[want]=heap[MAXChildNumber];
                want=MAXChildNumber;
            }
        }
    }

}

public int deleteTop(){
    if(currentSize<0){
        System.out.println("Sorry, this heap is empty!");
        return -1;
    }
    int target=heap[0];
    int substitute=heap[currentSize-1];
    this.currentSize--;
    heap[0]=substitute;
    siftDown(0);
    return target;
}

}

public class MaxHeapTest {
	 public static void main(String []args){
	        MaxHeap maxHeap=new MaxHeap(7);
	        for(int i=1;i<=7;i++){
	            maxHeap.insert(i);
	        }
	        for(int i=0;i<7;i++){
	            System.out.print(maxHeap.deleteTop()+"   ");
	        }
	        System.out.println("\n");
	    }
}

运行结果：