思路1：利用快排的思想，尋找第k個位置上正確的數，k位置前面的數即是比k位置小的陣列，k後面的數即是比k位置元素大的陣列

 public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (input==null||input.length==0||input.length<k||k<=0) {
            return res;
        }

        int start  = 0;
        int end = input.length-1;
        int index = partition(input, start, end);
        //一直迴圈知道找到第k個位置正確的數。
        while (index != k - 1) {
            if (index > k - 1) {
                end = index-1;
                index = partition(input, start, end);
            } else {
                start = index+1;
                index = partition(input, start, end);
            }

        }

        for (int i = 0; i < k; i++) {
            res.add(input[i]);
        }

        return res;
    }

   static int partition(int input[], int start, int end) {
        int tmp = input[start];
        while (start < end) {
            while (start < end && input[end] >= tmp) {
                end--;
            }
            input[start] = input[end];
            while (start < end && tmp >= input[start]) {
                start++;
            }
            input[end] = input[start];
        }
        input[start] = tmp;
        return start;
    }
 

思路2：利用堆排序，適用於海量資料尋找最大或最小的k個數字。

找最小的k個數，構建一個大頂堆，初始化容器大小為k，如果初始陣列小於等於k則直接返回，如果大於k，如果下一個數比堆頂元素大則直接丟棄，如果下一個數比堆頂元素小，則將堆頂元素替換，並重新調整堆結構。

當尋找最小的k個數是，使用大頂堆，大頂堆堆頂是該堆最大的元素，如果大於該堆頂，那麼肯定不是最小的k個數，將大於堆頂丟棄，小於堆頂元素替換。

當尋找最大的k個數時，使用小頂堆，小頂堆堆頂是該堆中最小的元素，如果小於該堆頂，那麼肯定不是最大的k個數，將該數丟棄，如果大於堆頂元素，那麼替換該最小數，並重新調整堆結構。

/堆排序：構建堆，不斷調整的過程，從最後一個不是葉子節點的節點開始。
    static public ArrayList<Integer> GetLeastNumbers_Solution1(int[] input, int k) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (input==null||input.length==0||input.length<k) {
            return res;
        }

        int []maxHeap = new int[k];
        //初始化堆
        for (int i = 0; i < maxHeap.length; i++) {
            maxHeap[i] = input[i];
        }
        //將初始化的堆調整為最大堆
        for (int i = (maxHeap.length-1)/2; i >=0 ; i--) {
            adjustHeap(maxHeap, i);
        }
        //遍歷初始陣列不斷調整最大堆
        for (int i = k; i <input.length ; i++) {
            if (maxHeap[0]>input[i]) {
                maxHeap[0] = input[i];
                adjustHeap(maxHeap, 0);
            }

        }

        for (int i = 0; i < maxHeap.length; i++) {
            res.add(maxHeap[i]);
        }

        return res;
    }

    static void adjustHeap(int maxHeap[],int i){

        int index = i;
        int lchild=2*i+1;       //i的左孩子節點序號 
        int rchild=2*i+2;     //i的右孩子節點序號 
        if(index<=(maxHeap.length-1)/2) {
            //尋找子節點中最大的節點
            if (lchild<maxHeap.length&&maxHeap[index]<maxHeap[lchild]) {
                index = lchild;
            }
            if (rchild<maxHeap.length&&maxHeap[index]<maxHeap[rchild]) {
                index = rchild;
            }

            if (i!=index) {
                //將節點與最大的子節點交換
                int tmp = maxHeap[index];
                maxHeap[index] = maxHeap[i];
                maxHeap[i] = tmp;
                //交換後，子樹可能不滿足最大推，遞迴調整。
                adjustHeap(maxHeap, index);
            }
        }