【刷穿 LeetCode】面试题 17.14. 最小K个数:「优先队列(堆)」&「全排序」&「数组划分」

简介: 【刷穿 LeetCode】面试题 17.14. 最小K个数:「优先队列(堆)」&「全排序」&「数组划分」

网络异常,图片无法展示
|

题目描述



这是 LeetCode 上的 面试题 17.14. 最小K个数 ,难度为 中等


Tag : 「优先队列」、「堆」、「排序」


设计一个算法,找出数组中最小的k个数。以任意顺序返回这k个数均可。


示例:


输入: arr = [1,3,5,7,2,4,6,8], k = 4
输出: [1,2,3,4]
复制代码


提示:


  • 0 <= len(arr) <= 100000
  • 0 <= k <= min(100000, len(arr))


优先队列(小根堆)



一个直观的想法是使用「优先队列(小根堆)」,起始将所有元素放入堆中,然后再从堆中取出 kk 个元素并「顺序」构造答案。


网络异常,图片无法展示
|


代码:


class Solution {
    public int[] smallestK(int[] arr, int k) {
        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);
        for (int i : arr) q.add(i);
        int[] ans = new int[k];
        for (int i = 0; i < k; i++) ans[i] = q.poll();
        return ans;
    }
}
复制代码


  • 时间复杂度:建堆复杂度为 O(n\log{n})O(nlogn),构造答案复杂度为 O(k\log{n})O(klogn)。整体复杂度为 O(n\log{n})O(nlogn)
  • 空间复杂度:O(n + k)O(n+k)


优先队列(大根堆)



在解法一中,我们将所有的原始都放入堆中,堆中元素最多有 nn 个,这导致了我们复杂度的上界为 O(n\log{n})O(nlogn)


而另外一个比较优秀的做法是,使用「优先队列(大根堆)」。


当处理到原始 arr[i]arr[i] 时,根据堆内元素个数,以及其与堆顶元素的关系分情况讨论:


  • 堆内元素不足 kk 个:直接将 arr[i]arr[i] 放入堆内;
  • 堆内元素为kk个:根据arr[i]arr[i]与堆顶元素的大小关系分情况讨论:
  • arr[i] >= heapToparr[i]>=heapToparr[i]arr[i] 不可能属于第 kk 小数(已有 kk 个元素在堆中),直接丢弃 arr[i]arr[i]
  • arr[i] < heapToparr[i]<heapToparr[i]arr[i] 可能属于第 kk 小数,弹出堆顶元素,并放入 arr[i]arr[i]


arrarr 被处理完,我们再使用堆中元素「逆序」构造答案。


网络异常,图片无法展示
|


代码:


class Solution {
    public int[] smallestK(int[] arr, int k) {
        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
        int[] ans = new int[k];
        if (k == 0) return ans;
        for (int i : arr) {
            if (q.size() == k && q.peek() <= i) continue;
            if (q.size() == k) q.poll();
            q.add(i);
        }
        for (int i = k - 1; i >= 0; i--) ans[i] = q.poll();
        return ans;
    }
}
复制代码


  • 时间复杂度:建堆复杂度为 O(n\log{k})O(nlogk),构造答案复杂度为 O(k\log{k})O(klogk)。整体复杂度为 O(n\log{k})O(nlogk)
  • 空间复杂度:O(k)O(k)


全排序



Java 中的 Arrays.sort 为综合排序实现。会根据数据规模、元素本身是否大致有序选择不同的排序实现。


因此一个比较省事的实现是先使用 Arrays.sort 进行排序,再构造答案。


网络异常,图片无法展示
|


代码:


class Solution {
    public int[] smallestK(int[] arr, int k) {
        Arrays.sort(arr);
        int[] ans = new int[k];
        for (int i = 0; i < k; i++) ans[i] = arr[i];
        return ans;
    }
}
复制代码


  • 时间复杂度:排序(假定 Arrays.sort 使用的是双轴快排实现)的复杂度为 O(n\log{n})O(nlogn);构造答案复杂度为 O(k)O(k)。整体复杂度为 O(n\log{n})O(nlogn)
  • 空间复杂度:O(\log{n} + k)O(logn+k)


快排数组划分



注意到题目要求「任意顺序返回这 kk 个数即可」,因此我们只需要确保前 kk 小的数都出现在下标为 [0, k)[0,k) 的位置即可。


利用「快速排序」的数组划分即可做到。


我们知道快排每次都会将小于等于基准值的值放到左边,将大于基准值的值放到右边。


因此我们可以通过判断基准点的下标 idxidxkk 的关系来确定过程是否结束:


  • idx < kidx<k:基准点左侧不足 kk 个,递归处理右边,让基准点下标右移;
  • idx > kidx>k:基准点左侧超过 kk 个,递归处理左边,让基准点下标左移;
  • idx = kidx=k:基准点左侧恰好 kk 个,输出基准点左侧元素。


网络异常,图片无法展示
|


代码:


class Solution {
    int k;
    public int[] smallestK(int[] arr, int _k) {
        k = _k;
        int n = arr.length;
        int[] ans = new int[k];
        if (k == 0) return ans;
        qsort(arr, 0, n - 1);
        for (int i = 0; i < k; i++) ans[i] = arr[i];
        return ans;
    }
    void qsort(int[] arr, int l, int r) {
        if (l >= r) return ;
        int i = l, j = r;
        int ridx = new Random().nextInt(r - l + 1) + l;
        swap(arr, ridx, l);
        int x = arr[l];
        while (i < j) {
            while (i < j && arr[j] >= x) j--;
            while (i < j && arr[i] <= x) i++;
            swap(arr, i, j);
        }
        swap(arr, i, l);
        // 集中答疑:因为题解是使用「基准点左侧」来进行描述(不包含基准点的意思),所以这里用的 k(写成 k - 1 也可以滴
        if (i > k) qsort(arr, l, i - 1);
        if (i < k) qsort(arr, i + 1, r);
    }
    void swap(int[] arr, int l, int r) {
        int tmp = arr[l];
        arr[l] = arr[r];
        arr[r] = tmp;
    }
}
复制代码


  • 时间复杂度:由于每次都会随机选择基准值,因此每次递归的数组平均长度为 n / 2n/2,那么划分数组操作的次数不会超过 2 * n2n。整体复杂度为 O(n)O(n)
  • 空间复杂度:O(\log{n})O(logn)


最后



这是我们「刷穿 LeetCode」系列文章的第 No.面试题 17.14 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。


在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。


为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:github.com/SharingSour…


在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。

相关文章
|
2月前
|
算法
Leetcode 初级算法 --- 数组篇
Leetcode 初级算法 --- 数组篇
43 0
|
2月前
【LeetCode-每日一题】 删除排序数组中的重复项
【LeetCode-每日一题】 删除排序数组中的重复项
23 4
|
2月前
|
索引
Leetcode第三十三题(搜索旋转排序数组)
这篇文章介绍了解决LeetCode第33题“搜索旋转排序数组”的方法,该问题要求在旋转过的升序数组中找到给定目标值的索引,如果存在则返回索引,否则返回-1,文章提供了一个时间复杂度为O(logn)的二分搜索算法实现。
24 0
Leetcode第三十三题(搜索旋转排序数组)
|
2月前
|
算法 C++
Leetcode第53题(最大子数组和)
这篇文章介绍了LeetCode第53题“最大子数组和”的动态规划解法,提供了详细的状态转移方程和C++代码实现,并讨论了其他算法如贪心、分治、改进动态规划和分块累计法。
70 0
|
2月前
|
C++
【LeetCode 12】349.两个数组的交集
【LeetCode 12】349.两个数组的交集
19 0
|
4月前
|
算法
LeetCode第81题搜索旋转排序数组 II
文章讲解了LeetCode第81题"搜索旋转排序数组 II"的解法,通过二分查找算法并加入去重逻辑来解决在旋转且含有重复元素的数组中搜索特定值的问题。
LeetCode第81题搜索旋转排序数组 II
|
4月前
|
开发者 索引 Python
这些年背过的面试题——LeetCode
本文是技术人面试系列LeetCode篇,一文带你详细了解,欢迎收藏!
|
4月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输,之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
|
1月前
|
存储 缓存 算法
面试官:单核 CPU 支持 Java 多线程吗?为什么?被问懵了!
本文介绍了多线程环境下的几个关键概念,包括时间片、超线程、上下文切换及其影响因素,以及线程调度的两种方式——抢占式调度和协同式调度。文章还讨论了减少上下文切换次数以提高多线程程序效率的方法,如无锁并发编程、使用CAS算法等,并提出了合理的线程数量配置策略,以平衡CPU利用率和线程切换开销。
面试官:单核 CPU 支持 Java 多线程吗?为什么?被问懵了!
|
1月前
|
存储 算法 Java
大厂面试高频:什么是自旋锁?Java 实现自旋锁的原理?
本文详解自旋锁的概念、优缺点、使用场景及Java实现。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
大厂面试高频:什么是自旋锁?Java 实现自旋锁的原理?
下一篇
DataWorks