【剑指Offer】个人学习笔记_40_最小的k个数

最新推荐文章于 2021-05-25 21:30:29 发布

JonnySu

最新推荐文章于 2021-05-25 21:30:29 发布

阅读量142

点赞数

分类专栏： Coding 文章标签：算法快速排序 java 排序算法 leetcode

本文链接：https://blog.csdn.net/qq_39295220/article/details/116462075

版权

Coding 专栏收录该内容

64 篇文章 0 订阅

订阅专栏

题目：

剑指 Offer 40. 最小的k个数

难度简单237

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

限制：

0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

题目分析

直观来想就是简单的排序加数组操作。

初始解答：

尝试初步实现

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //首先排序
        Arrays.sort(arr);
        int[] res = new int [k];
        for(int i = 0; i < k; i++) res[i] = arr[i];
        return res;
    }
}

执行结果：通过

显示详情

添加备注

执行用时：8 ms, 在所有 Java 提交中击败了67.56%的用户

内存消耗：39.8 MB, 在所有 Java 提交中击败了57.99%的用户

这道题要的不是一个数，所以就用不了摩尔投票，如果有直接在原数组上截取的方法就更快了。

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //首先排序
        Arrays.sort(arr);
        return Arrays.copyOfRange(arr, 0, k);
    }
}

果然是有的。

执行结果：通过

显示详情

添加备注

执行用时：7 ms, 在所有 Java 提交中击败了72.77%的用户

内存消耗：39.6 MB, 在所有 Java 提交中击败了79.71%的用户

排序算法是硬伤啊，用的多了就熟练了吧。

学习他人：

方法一:

Sweetiee 🍬L6 （编辑过）2020-03-20 很全面，如果需要确实移步公众号，不过这道题难度就仅仅只是考对几种排序算法的熟练程度吗。

🌟🌟🌟UPDATE：米娜桑中午好～ wx公众号【甜姨的奇妙冒险】新鲜出炉了本题的文章，内含更加详细的技巧与解释，请肆意猛戳！！

另外，刚刚创建了我的知乎专栏【甜姨的力扣题解】会写很多高质量题解，快到碗里来～

------

🙋所有男生女生我来咯！

❤️4种解法秒杀TopK：快排 / 堆 / 二叉搜索树 / 计数排序

最全分析请直戳戳戳我的题解ξ( ✿＞◡❛)

1.快排：

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 最后一个参数表示我们要找的是下标为k-1的数
        return quickSearch(arr, 0, arr.length - 1, k - 1);
    }

    private int[] quickSearch(int[] nums, int lo, int hi, int k) {
        // 每快排切分1次，找到排序后下标为j的元素，如果j恰好等于k就返回j以及j左边所有的数；
        int j = partition(nums, lo, hi);
        if (j == k) {
            return Arrays.copyOf(nums, j + 1);
        }
        // 否则根据下标j与k的大小关系来决定继续切分左段还是右段。
        return j > k? quickSearch(nums, lo, j - 1, k): quickSearch(nums, j + 1, hi, k);
    }

    // 快排切分，返回下标j，使得比nums[j]小的数都在j的左边，比nums[j]大的数都在j的右边。
    private int partition(int[] nums, int lo, int hi) {
        int v = nums[lo];
        int i = lo, j = hi + 1;
        while (true) {
            while (++i <= hi && nums[i] < v);
            while (--j >= lo && nums[j] > v);
            if (i >= j) {
                break;
            }
            int t = nums[j];
            nums[j] = nums[i];
            nums[i] = t;
        }
        nums[lo] = nums[j];
        nums[j] = v;
        return j;
    }
}

2.大根堆

// 保持堆的大小为K，然后遍历数组中的数字，遍历的时候做如下判断：
// 1. 若目前堆的大小小于K，将当前数字放入堆中。
// 2. 否则判断当前数字与大根堆堆顶元素的大小关系，如果当前数字比大根堆堆顶还大，这个数就直接跳过；
//    反之如果当前数字比大根堆堆顶小，先poll掉堆顶，再将该数字放入堆中。
class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 默认是小根堆，实现大根堆需要重写一下比较器。
        Queue<Integer> pq = new PriorityQueue<>((v1, v2) -> v2 - v1);
        for (int num: arr) {
            if (pq.size() < k) {
                pq.offer(num);
            } else if (num < pq.peek()) {
                pq.poll();
                pq.offer(num);
            }
        }
        
        // 返回堆中的元素
        int[] res = new int[pq.size()];
        int idx = 0;
        for(int num: pq) {
            res[idx++] = num;
        }
        return res;
    }
}

3.二叉搜索树

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中当前数字对应个数+1
            if (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;
    }
}

计数排序

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;
    }
}

方法二：

张三L1 2021-03-18

我不想努力了

 public int[] getLeastNumbers(int[] arr, int k) {
        Arrays.sort(arr);
        return Arrays.copyOfRange(arr, 0, k);
    }

方法三：

爱吃喵酱的花椒L1 2021-02-18

解法一：排序，复杂度O(nlogn)

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        Arrays.sort(arr);
        return Arrays.copyOfRange(arr,0,k);
    }
}

解法二：大根堆，复杂度O(nlogk)

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        Queue<Integer> pq = new PriorityQueue<>((v1, v2) -> v2 - v1);
        for (int num: arr) {
            if (pq.size() < k) {
                pq.offer(num);
            } else if (num < pq.peek()) {
                pq.poll();
                pq.offer(num);
            }
        }
        int[] res = new int[pq.size()];
        int idx = 0;
        for(int num: pq) {
            res[idx++] = num;
        }
        return res;
    }
}

解法三：patition,复杂度O(n)

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(k==0||arr.length==0)
        return new int[0];
        int lo=0,hi=arr.length-1;
        int index=partition(arr,lo,hi);
        while(index!=k-1)
            {
             if(index>k-1)
             {
                 hi=index-1;
                 index=partition(arr,lo,hi);
             }
             else{
                 lo=index+1;
                 index=partition(arr,lo,hi);
             }  
            }
            return Arrays.copyOf(arr,index+1);
    }
    public int partition(int[] nums,int lo,int hi){
       int target=nums[lo];
        while(lo<hi){
            while(lo<hi&&nums[hi]>=target)hi--;
            if(lo<hi)nums[lo++]=nums[hi];
            while(lo<hi&&nums[lo]<target)lo++;
            if(lo<hi)nums[hi--]=nums[lo];
        }
        nums[lo]=target;
        return lo;
    }
}

方法四：

K神

作者：jyd
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/jian-zhi-offer-40-zui-xiao-de-k-ge-shu-j-9yze/
来源：力扣（LeetCode）

方法一：排序

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        quickSort(arr, 0, arr.length - 1);
        return Arrays.copyOf(arr, k);
    }
    private void quickSort(int[] arr, int l, int r) {
        // 子数组长度为 1 时终止递归
        if (l >= r) return;
        // 哨兵划分操作（以 arr[l] 作为基准数）
        int i = l, j = r;
        while (i < j) {
            while (i < j && arr[j] >= arr[l]) j--;
            while (i < j && arr[i] <= arr[l]) i++;
            swap(arr, i, j);
        }
        swap(arr, i, l);
        // 递归左（右）子数组执行哨兵划分
        quickSort(arr, l, i - 1);
        quickSort(arr, i + 1, r);
    }
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

方法二： 基于快速排序的数组划分

题目只要求返回最小的 k 个数，对这 k 个数的顺序并没有要求。因此，只需要将数组划分为最小的 kk 个数和其他数字两部分即可，而快速排序的哨兵划分可完成此目标。

根据快速排序原理，如果某次哨兵划分后基准数正好是第 k+1k+1 小的数字，那么此时基准数左边的所有数字便是题目所求的最小的 k 个数。

根据此思路，考虑在每次哨兵划分后，判断基准数在数组中的索引是否等于 kk ，若 truetrue 则直接返回此时数组的前 kk 个数字即可。

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k >= arr.length) return arr;
        return quickSort(arr, k, 0, arr.length - 1);
    }
    private int[] quickSort(int[] arr, int k, int l, int r) {
        int i = l, j = r;
        while (i < j) {
            while (i < j && arr[j] >= arr[l]) j--;
            while (i < j && arr[i] <= arr[l]) i++;
            swap(arr, i, j);
        }
        swap(arr, i, l);
        if (i > k) return quickSort(arr, k, l, i - 1);
        if (i < k) return quickSort(arr, k, i + 1, r);
        return Arrays.copyOf(arr, k);
    }
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

总结

以上就是本题的内容和学习过程了，主要还是考排序算法，正好分享一下上周学习数据结构的笔记。
在这里插入图片描述

欢迎讨论，共同进步。

JonnySu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
4
评论
【剑指Offer】个人学习笔记_40_最小的k个数

目录题目：[剑指 Offer 40. 最小的k个数](https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/)题目分析初始解答：学习他人：方法一:方法二：方法三：方法四：总结刷题日期：20:0047 星期四2021年5月6日个人刷题记录，代码收集，来源皆为leetcode经过多方讨论和请教，现在打算往Java方向发力主要答题语言为Java题目：剑指 Offer 40. 最小的k个数难度简单237输入整数数组 arr ，找出其中
复制链接

扫一扫

专栏目录