寻找数组最小小的k个数

思路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);
            }
        }

参考

https://blog.csdn.net/liuguangqiang/article/details/52210239