[剑指offer][JAVA][面试第40题][最小的k个数][快选][堆][BST]

【问题描述】面试第40题最小的k个数

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 ：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

【解答思路】

1. Arrays.sort

需要先把该数组排序（从小到大）。
截取前k个数返回需要的数组。
时间复杂度：O(N^2) 空间复杂度：O(N)

class Solution {public int[] getLeastNumbers(int[] arr, int k) {Arrays.sort(arr);int[] a = new int[k] ;/*for(int j = 0; j <  k ; j++){a[j] = arr[j];}*/System.arraycopy(arr, 0, a, 0, k);return a;//return Arrays.copyOfRange(arr, 0, k);}
}

2. 堆

使用堆数据结构来辅助得到最小的 k 个数。堆的性质是每次可以找出最大或最小的元素。我们可以使用一个大小为 k 的最大堆（大顶堆），将数组中的元素依次入堆，当堆的大小超过 k 时，便将多出的元素从堆顶弹

时间复杂度：O(Nlogk) 空间复杂度：O(k)
使用了一个大小为 k 的堆

public int[] getLeastNumbers(int[] arr, int k) {if (k == 0) {return new int[0];}// 使用一个最大堆（大顶堆）// Java 的 PriorityQueue 默认是小顶堆，添加 comparator 参数使其变成最大堆Queue<Integer> heap = new PriorityQueue<>(k, (i1, i2) -> Integer.compare(i2, i1));for (int e : arr) {// 当前数字小于堆顶元素才会入堆if (heap.isEmpty() || heap.size() < k || e < heap.peek()) {heap.offer(e);}if (heap.size() > k) {heap.poll(); // 删除堆顶最大元素}}// 将堆中的元素存入数组int[] res = new int[heap.size()];int j = 0;for (int e : heap) {res[j++] = e;}return res;
}作者：nettee
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/tu-jie-top-k-wen-ti-de-liang-chong-jie-fa-you-lie-/

3. 快排变形

“查找第 k 大的元素”是一类算法问题，称为选择问题。
找第 k 大的数，或者找前 k 大的数，有一个经典的 quick select（快速选择）算法。
这个名字和 quick sort（快速排序）很像，算法的思想也和快速排序类似，都是分治法的思想

partition
时间复杂度：期望O(N) 最坏O(N^2) 空间复杂度：O(1)

public int[] getLeastNumbers(int[] arr, int k) {if (k == 0) {return new int[0];} else if (arr.length <= k) {return arr;}// 原地不断划分数组partitionArray(arr, 0, arr.length - 1, k);// 数组的前 k 个数此时就是最小的 k 个数，将其存入结果int[] res = new int[k];for (int i = 0; i < k; i++) {res[i] = arr[i];}return res;
}void partitionArray(int[] arr, int lo, int hi, int k) {// 做一次 partition 操作int m = partition(arr, lo, hi);// 此时数组前 m 个数，就是最小的 m 个数if (k == m) {// 正好找到最小的 k(m) 个数return;} else if (k < m) {// 最小的 k 个数一定在前 m 个数中，递归划分partitionArray(arr, lo, m-1, k);} else {// 在右侧数组中寻找最小的 k-m 个数partitionArray(arr, m+1, hi, k);}
}// partition 函数和快速排序中相同，具体可参考快速排序相关的资料
// 代码参考 Sedgewick 的《算法4》
int partition(int[] a, int lo, int hi) {int i = lo;int j = hi + 1;int v = a[lo];while (true) { while (a[++i] < v) {if (i == hi) {break;}}while (a[--j] > v) {if (j == lo) {break;}}if (i >= j) {break;}swap(a, i, j);}swap(a, lo, j);// a[lo .. j-1] <= a[j] <= a[j+1 .. hi]return j;
}void swap(int[] a, int i, int j) {int temp = a[i];a[i] = a[j];a[j] = temp;
}作者：nettee
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/tu-jie-top-k-wen-ti-de-liang-chong-jie-fa-you-lie-/

4. 计数排序

时间复杂度：O(N) 空间复杂度：O(N)

class Solution {public int[] getLeastNumbers(int[] arr, int k) {if (k == 0 || arr.length == 0) {return new int[0];}// 统计每个数字出现的次数int[] counter = new int[10001];for (int num: arr) {counter[num]++;}// 根据counter数组从头找出k个数作为返回结果int[] res = new int[k];int idx = 0;for (int num = 0; num < counter.length; num++) {while (counter[num]-- > 0 && idx < k) {res[idx++] = num;}if (idx == k) {break;}}return res;}
}作者：sweetiee
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/3chong-jie-fa-miao-sha-topkkuai-pai-dui-er-cha-sou/

5. 二叉搜索树BST（前K大有序）

class Solution {public int[] getLeastNumbers(int[] arr, int k) {if (k == 0 || arr.length == 0) {return new int[0];}// TreeMap的key是数字, value是该数字的个数。// cnt表示当前map总共存了多少个数字。TreeMap<Integer, Integer> map = new TreeMap<>();int cnt = 0;for (int num: arr) {// 1. 遍历数组，若当前map中的数字个数小于k，则map中当前数字对应个数+1if (cnt < k) {map.put(num, map.getOrDefault(num, 0) + 1);cnt++;continue;} // 2. 否则，取出map中最大的Key（即最大的数字), 判断当前数字与map中最大数字的大小关系：//    若当前数字比map中最大的数字还大，就直接忽略；//    若当前数字比map中最大的数字小，则将当前数字加入map中，并将map中的最大数字的个数-1。Map.Entry<Integer, Integer> entry = map.lastEntry();if (entry.getKey() > num) {map.put(num, map.getOrDefault(num, 0) + 1);if (entry.getValue() == 1) {map.pollLastEntry();} else {map.put(entry.getKey(), entry.getValue() - 1);}}}// 最后返回map中的元素int[] res = new int[k];int idx = 0;for (Map.Entry<Integer, Integer> entry: map.entrySet()) {int freq = entry.getValue();while (freq-- > 0) {res[idx++] = entry.getKey();}}return res;}
}作者：sweetiee
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/3chong-jie-fa-miao-sha-topkkuai-pai-dui-er-cha-sou/

时间复杂度：O(NlogN) 空间复杂度：O(N)

【总结】

1.堆/快速选择比较

看起来分治法的快速选择算法的时间、空间复杂度都优于使用堆的方法，但是要注意到快速选择算法的几点局限性：

算法需要修改原数组，如果原数组不能修改的话，还需要拷贝一份数组，空间复杂度就上去了。
算法需要保存所有的数据。如果把数据看成输入流的话，使用堆的方法是来一个处理一个，不需要保存数据，只需要保存 k 个元素的最大堆。而快速选择的方法需要先保存下来所有的数据，再运行算法。当数据量非常大的时候，甚至内存都放不下的时候，就麻烦了。所以当数据量大的时候还是用基于堆的方法比较好