解題思路：一般思路就是將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");
	    }
}

執行結果：