【剑指offer题解】【Java】最小的k个数

在这里插入图片描述

前言

众所周知,《剑指offer》是一本“好书”。

为什么这么说?

因为在面试老鸟眼里,它里面罗列的算法题在面试中出现的频率是非常非常高的。

有多高,以我目前不多的面试来看,在所有遇到的面试算法题中,出现原题的概率大概能有6成,如果把基于原题的变种题目算上,那么这个出现概率能到达9成,10题中9题见过。

如果你是个算法菜鸡(和我一样),那么最推荐的是先把剑指offer的题目搞明白。

至于为什么给“好书”这两个字打引号,因为这本书成了面试官的必备,如果考生不会这本书上的题目,就很可能得到面试官负面的评价。这本书快要成为评判学生算法能力的唯一标准,这使得考前突击变成了一个惯例,反而让投机倒把成了必要,并不一定能真正的考察考生的算法能力。

对于剑指offer题解这个系列,我的写文章思路是,对于看了文章的读者,能够:

  • 迅速了解该题常见解答思路(奇技淫巧不包括在内,节省大家时间,实在有研究需求的人可以查阅其它资料)
  • 思路尽量贴近原书(例如书中提到的面试官经常会要求不改变原数组,或者有空间限制等,尽量体现在代码中,保证读者可以不漏掉书中细节)
  • 尽量精简话语,避免冗长解释
  • 给出代码可运行,注释齐全,对细节进行解释

题目介绍

输入n个整数,找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字,则最小的4个数字是1,2,3,4,。

本体分类:优化时间和空间效率

解题思路

初始思路:直接排序 O(nlogn)

直接对数组排序,排序后前k个数就是答案,排序一般较快的是O(nlogn),显然这并不是时间复杂度最优解。

方法一:基于快速排序的变种 O(n)

思路

该方法需要改变原数组。

还记得上一题:数组中超过一半的数字么?这一题的思路和上题类似,仅仅是换成了k个最小的数字。

这种算法是受快速排序算法的启发。

在随机快速排序算法中,我们先数组中随机选择一个数字,然后调整数组中数字的顺序,使得比选中的数字小的数字都排在它的左边,比选中的数字大的数字都排在它的右边。如果这个选中的数字的下标刚好是k,我们就得到了k个小的数字,这些数字在k的左边,并且没有经过排序,但是都比k小。

如果它的下标大于k,我们可以接着在它的左边部分的数组中查找。

如果它的下标小于k,那么中位数应该位于它的右边,我们可以接着在它的右边部分的数组中查找。

这是一个典型的递归过程

详细细节见代码注释。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
// 由于本题需要返回ArrayList<Integer>,所以新建之
ArrayList<Integer> list = new ArrayList<>();
// 若输入数组长度小于k。直接返回数空的ArrayList
if(input.length < k){
return list;
}

findKMin(input,0,input.length-1,k);
for(int i = 0; i < k; i++){
list.add(input[i]);
}
return list;
}

private void findKMin(int[] a, int start, int end, int k){
if(start < end){
int pos = partition(a, start, end);
if(pos == k-1){
return ;
}else if(pos < k-1){
findKMin(a,pos+1,end,k);
}else{
findKMin(a,start,pos-1,k);
}
}
}

// 快排中的每次排序实现(挖坑填数法),返回的是交换后start位置(快排一次后的中轴点,中轴点左边全是小于它的,右边都是大于它的)
public int partition(int[] a, int start, int end){
int pivot = a[start];
while(start < end){
while(start < end && a[end] >= pivot){end--;};
a[start] = a[end];
while(start < end && a[start] <= pivot){start++;};
a[end] = a[start];
}
a[start] = pivot;
return start;
}
}

方法二:适合海量数据的最大堆 O(nlogk)

思路

该方法不改变原数组,但时间复杂度比O(n)略微复杂了些。

构造一个最大堆,最大堆的性质就是堆顶是所有堆中数字的最大值,那么放入k个数字,随后将数字中k个数字之后的数字依次和堆中的最大数字比较(也就是和堆顶数字比较),如果小于他,就把堆顶数字弹出,放入小的数字,这样遍历一边数组后,得到一个k个数字的最大堆,这个最大堆里存的是最小的k个数。

最大堆的性质由Java中的优先队列,通过自然数的逆序顺序进行维护,也就是下面这句构造:

1
Queue<Integer> queue = new PriorityQueue<>(k, Collections.reverseOrder());

有的小伙伴会问,为啥最大堆是最小的k个数?

答:说明你对堆还不够了解,恶补一下堆的性质吧~

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution_2(int [] input, int k) {
// 由于本题需要返回ArrayList<Integer>,所以新建之
ArrayList<Integer> res = new ArrayList<>();
// 几种特殊情况
if (k > input.length|| k == 0) {
return res;
}
// 构造优先队列,排序方法是自然数顺序的逆序,所以是个最大堆,这样这个堆的堆顶就是所有数中的最大数
Queue<Integer> queue = new PriorityQueue<>(k, Collections.reverseOrder());

for (int i = 0; i < input.length; i++) {
// 最大堆内数字个数少于k,一直添加到k个
if (queue.size() < k) {
queue.add(input[i]);
}
else {
// 若堆内最大的数字大于数组中的数字,则将数字出堆,并放入这个小的数
if (input[i] < queue.peek()) {
queue.remove();
queue.add(input[i]);
}
}
}

// 结束上面循环后,堆内就是最小的k个数
while (!queue.isEmpty()) {
res.add(queue.remove());
}
return res;
}


public static void main(String[] args) {
int[] a = {4,5,1,6,2,7,3,8};
Solution_40 solution_40 = new Solution_40();
System.out.println(solution_40.GetLeastNumbers_Solution(a,4));
}
}

总结

书中提到,第二种堆的方法适合海量数据求k个最小。因为k个数的堆,空间是固定的,当数组超级大,那么全存入内存都变得不可行的时候,就需要从外存中慢慢读取数字,然后和这个堆进行比较。

而方法一就必须吧整个数组放入内存中,才能运行,所以不适合海量数据。

关注我

我目前是一名后端开发工程师。技术领域主要关注后端开发,数据爬虫,数据安全,5G,物联网等方向。

微信:yangzd1102

Github:@qqxx6661

个人博客:

原创博客主要内容

  • Java知识点复习全手册
  • Leetcode算法题解析
  • 剑指offer算法题解析
  • SpringCloud菜鸟入门实战系列
  • SpringBoot菜鸟入门实战系列
  • Python爬虫相关技术文章
  • 后端开发相关技术文章

个人公众号:Rude3Knife

个人公众号:Rude3Knife

如果文章对你有帮助,不妨收藏起来并转发给您的朋友们~