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进制数表示分治讨论、用堆排序维护最小值数组等等算法。