1-最小的k个数

最新推荐文章于 2023-04-01 13:55:15 发布

MaoziShan

最新推荐文章于 2023-04-01 13:55:15 发布

阅读量186

点赞数 1

分类专栏：剑指offer 文章标签：冒泡排序快速排序大根堆最小k个数优先队列

本文链接：https://blog.csdn.net/MaoziYa/article/details/115286984

版权

剑指offer 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

题目描述

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

这是标注为“简单”的一道题目，但是题解版本很多，涉及的点也很深很全（菜鸟本菜），因此记录下自己的学习过程。

Me

我的解题思路是使用冒泡排序算法，具体代码如下：

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        int [] result = new int[k];
        int tmp, index = 0;
        boolean b = true, cont = true;
        while (index < k) {
            // b记录一次冒泡过程中是否发生了数据交换
            b = false;
            // 一次冒泡
            for (int i=arr.length-1; i>0 && cont; i--) {
                if (arr[i] < arr[i-1]) {
                    tmp = arr[i];
                    arr[i] = arr[i-1];
                    arr[i-1] = tmp;
                    b = true;
                }
            }
            // 如果数据没有发生交换，说明当前序列已经有序，将cont设置为false，停止冒泡
            if (b == false) cont=false;
            // 每次冒泡之后index对应的值是排序第(index+1)的最小值
            result[index] = arr[index];
            index ++;    
        }
        return result;
    }
}

可以明显看出来，写得不是很优雅，用时和内存消耗也只超过了百分之十左右的同学。

执行用时: 850 ms
内存消耗: 40 MB

快排

啥是快排？官方作者给的解释如下。好晕……

我们知道快排的划分函数每次执行完后都能将数组分成两个部分，小于等于分界值 pivot 的元素的都会被放到数组的左边，大于的都会被放到数组的右边，然后返回分界值的下标。与快速排序不同的是，快速排序会根据分界值的下标递归处理划分的两侧，而这里我们只处理划分的一边。

我们定义函数 randomized_selected(arr, l, r, k) 表示划分数组 arr 的 [l,r] 部分，使前 k 小的数在数组的左侧，在函数里我们调用快排的划分函数，假设划分函数返回的下标是 pos（表示分界值 pivot 最终在数组中的位置），即 pivot 是数组中第 pos - l + 1 小的数，那么一共会有三种情况：

如果 pos - l + 1 == k，表示 pivot 就是第 k 小的数，直接返回即可；

如果 pos - l + 1 < k，表示第 k 小的数在 pivot 的右侧，因此递归调用 randomized_selected(arr, pos + 1, r, k - (pos - l + 1))；

如果 pos - l + 1 > k，表示第 k 小的数在 pivot 的左侧，递归调用 randomized_selected(arr, l, pos - 1, k)。

函数递归入口为 randomized_selected(arr, 0, arr.length - 1, k)。在函数返回后，将前 k 个数放入答案数组返回即可。

直接解析代码：

class Solution {
    public static int[] getLeastNumbers(int[] arr, int k) {
        randomizedSelected(arr, 0, arr.length - 1, k);
        int[] vec = new int[k];
        for (int i = 0; i < k; ++i) {
            vec[i] = arr[i];
        }
        return vec;
    }

    // 递归调用，最终arr的前k个值为前k最小值
    private static void randomizedSelected(int[] arr, int l, int r, int k) {
        if (l >= r) {
            return;
        }
        // pos为随机取值快排后的分界索引
        int pos = randomizedPartition(arr, l, r);
        // num为以pos位的值为分界值后时pos与l之间的值的个数
        int num = pos - l + 1;
        if (k == num) {
            return;
        } else if (k < num) {
            randomizedSelected(arr, l, pos - 1, k);
        } else {
            randomizedSelected(arr, pos + 1, r, k - num);
        }
    }

    // 基于随机的划分
    private static int randomizedPartition(int[] nums, int l, int r) {
        // 随机生成index i， 此值用于选取分界值; Random().nextInt(x)生成一个范围在0~x（不包含x）内的任意正整数
        int i = new Random().nextInt(r - l + 1) + l;
        // 交换nums中index为r和i的值
        swap(nums, r, i);
        // 以r位置的值为分界值，最后返回的数值为r位置对应的值所处的位置
        return partition(nums, l, r);
    }

    // 该方法返回的新的数组中，以(i+1)位置作为分界，左侧为小于或等于r位数值的值，右侧为大于r位数值的值，(i+1)位置的数值为r
    private static int partition(int[] nums, int l, int r) {
        int pivot = nums[r];
        int i = l - 1;
        for (int j = l; j <= r - 1; ++j) {
            if (nums[j] <= pivot) {
                i = i + 1;
                swap(nums, i, j);
            }
        }
        swap(nums, i + 1, r);
        return i + 1;
    }

    // 交换nums中i和j位的数值
    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/zui-xiao-de-kge-shu-by-leetcode-solution/
来源：力扣（LeetCode）

堆

我们用一个大根堆实时维护数组的前 k 小值。首先将前 k 个数插入大根堆中，随后从第 k+1 个数开始遍历，如果当前遍历到的数比大根堆的堆顶的数要小，就把堆顶的数弹出，再插入当前遍历到的数。最后将大根堆里的数存入数组返回即可。在下面的代码中，由于 C++ 语言中的堆（即优先队列）为大根堆，我们可以这么做。而 Python 语言中的堆为小根堆，因此我们要对数组中所有的数取其相反数，才能使用小根堆维护前 k 小值。

class Solution {
	public static int[] getLeastNumbers(int[] arr, int k) {
        int[] vec = new int[k];
        if (k == 0) { // 排除 0 的情况
            return vec;
        }
        // PriorityQueue默认是一个小顶堆，然而可以通过传入自定义的Comparator函数来实现大顶堆。
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            public int compare(Integer num1, Integer num2) {
                return num2 - num1;
            }
        });
        for (int i = 0; i < k; ++i) {
            queue.offer(arr[i]);
        }
        for (int i = k; i < arr.length; ++i) {
            if (queue.peek() > arr[i]) {
                queue.poll();
                queue.offer(arr[i]);
            }
        }
        for (int i = 0; i < k; ++i) {
            vec[i] = queue.poll();
        }
        return vec;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/zui-xiao-de-kge-shu-by-leetcode-solution/
来源：力扣（LeetCode）