java 最快获取最小前K个数

从一列n个数字中取最小的前k个数字。这是一个面试经常会问到问题，回答这个问题并不难，但是如何能分析出最优的算法，能够分析出多少种算法，这会是面试官真正感兴趣的问题。这里总结一下这个问题的所有解法与复杂度。

1. 快速排序法 O(N*logN)

---

最简单直接的方法就是快速排序+返回前k个数字。快速排序是复杂度为N*logN的算法，而查找前k个数字需要是时间复杂度为O(K)。总体的时间复杂度为O(N*logN)。

public class Main {

    public static void main(String[] args) {
        int[] arr = {1, 4, 3, 5, 7, 6, 2, 8, 9};
        //模拟需要排序的数组
        int k = 4;
        //模拟需要返回的前k个最大数字
        int res[] = qSAndBS(arr, k);
    }

    private static int[] qSAndBS(int[] arr, int k) {
        quickSort(arr, 0, arr.length - 1);
        int[] res = new int[k];
        for (int i = 0; i < k; i++)
            res[i] = arr[i];
        return res;
    }

    private static void quickSort(int[] arr, int start, int end) {
        if (start >= end) return;
        int index = start, i = start, j = end + 1;
        while (true) {
            while (arr[++i] <= arr[index]) if (i == end) break;
            while (arr[--j] >= arr[index]) if (j == index) break;
            if (j <= i) break;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        int temp = arr[j];
        arr[j] = arr[index];
        arr[index] = temp;
        index = j;
        quickSort(arr, start, index - 1);
        quickSort(arr, index + 1, end);
    }

}

2. 部分排序法 O(N*K)

---

实际上我们并不需要将整个数组进行排序，因为我们仅仅关心前K个最小的数字，这个时候我们可以考虑部分排序法，仅仅将我们需要的前K个数字排序。部分排序采用选择排序和插入排序较好，插入排序稳定，但是在元素较大的时候交换次数多的一塌糊涂，而选择排序正好又是所有的排序中交换次数最少的一种。两种算法各有优劣，一般来讲，这两种排序的复杂度为n²，但在这种情况下，我们仅需要前k个数字，因此仅需N*K的复杂度。在具体计算的时候我们要估计K与logN之间的大小关系，选择最优的算法。

public class Main {

    public static void main(String[] args) {
        int[] arr = {1, 4, 3, 5, 7, 6, 2, 8, 9};
        //模拟需要排序的数组
        int k = 4;
        //模拟需要返回的前k个最大数字
        int res[] = cSAndRe(arr, k);
    }

    private static int[] cSAndRe(int[] arr, int k) {
        chooseSort(arr, k);
        int[] res = new int[k];
        for (int i = 0; i < k; i++)
            res[i] = arr[i];
        return res;
    }

    private static void chooseSort(int[] arr, int k) {
        for (int i = 0; i < k; i++) {
            int index = i;
            for (int j = i; j < arr.length; j++)
                if (arr[index] > arr[j]) index = j;
            int temp = arr[index];
            arr[index] = arr[i];
            arr[i] = temp;
        }
    }

}

3.以k为分界的分治排序思想 O(N*logK)

---

上述两种做法不仅适用于这道题目，实际上适合很多类似的题目，这种算法拿出来并没有什么创新之处，真正能切合当前题目的算法会为我们带来更小的复杂度开支。比如这种复杂度为N*logK的算法大概思路是这样的，在快排中我们以一个数作为分界将数组一分为二，分别对各个部分进行递归，那么在这道题目中，我们所关心的是数组中最小的前k个数，也可以借鉴类似快排的思路：

对于一个分界值所分割的两部分存在两种情况，第一种情况是较小的部分的数量大于k，第二种情况是较小的部分数量n个但n

    public static void main(String[] args) {
        int[] arr = {1, 4, 3, 5, 7, 6, 2, 8, 9};
        //模拟需要排序的数组
        int k = 4;
        //模拟需要返回的前k个最大数字
        int res[] = kSAndRe(arr, k);
        for (int i = 0; i < k; i++)
            System.out.println(res[i]);
    }

    private static int[] kSAndRe(int[] arr, int k) {
        int[] res = new int[k];
        for (int i = 0; i < k; i++)
            res[i] = -1;
        keySort(arr, 0, arr.length - 1, k, res);
        return res;
    }

    private static void keySort(int[] arr, int start, int end, int k, int[] res) {
        if (start >= end || k <= 0)
            return;
        int index = start;
        int i = start, j = end + 1;
        while (true) {
            while (arr[index] > arr[++i]) if (i == end) break;
            while (arr[index] < arr[--j]) if (j == start) break;
            if (i >= j)
                break;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        int temp = arr[index];
        arr[index] = arr[j];
        arr[j] = temp;
        index = j;
        if (index - start + 1 > k) keySort(arr, start, index - 1, k, res);
        else {
            for (i = 0, j = 0; j < index - start + 1; i++)
                if (res[i] == -1) res[i] = arr[start + (j++)];
            if (index - start + 1 == k) return;
            else keySort(arr, index + 1, end, k - index + start - 1, res);
        }

    }

}

4.其他解题算法

---

这道题的思路还有很多，作为一道开放性的思考题，不适合被拿到oj上评判一个人的算法能力，对于这道题的其他解决方法，还有类似于：用2进制数表示分治讨论、用堆排序维护最小值数组等等算法。