剑指 Offer 40. 最小的k个数

一、题目

题目链接：力扣

输入整数数组 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

---

二、题解

1、思路

🚚 sort 快速排序

对原数组从小到大排序后取出前 k 个数即可。快排我使用的sort函数，但是最好自己写一下。如果想自己写可以参考之前的文章https://blog.csdn.net/qq_41709234/article/details/129332549，或者力扣，或者排序算法--快速排序--详解与代码示例_快速排序算法_阿尔兹的博客-CSDN博客。

下面感受一下来自力扣评论区的嘲讽：

🚚 基于快速排序的数组划分

快速排序中的哨兵pivot，假设升序排序，左侧的数字都小于pivot，右侧的数字都大于pivot，也就是说pivot的位置已经是排序后的最终位置，那么pivot的下标刚好等于k，那么pivot左侧的数字便是最终结果。

详见力扣方法二的动图。

2、代码实现

🚚 sort 快速排序

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> res;
        sort(arr.begin(), arr.end());
        for(int i = 0; i < k; i++)
        {
            res.emplace_back(arr[i]);
        }
        return res;
    }
};

🚚 基于快速排序的数组划分

易错点：返回值res定义的位置。 

下面这是第一次的写法，每次都递归之前都定义一个res，保证每次都是最新的，而且对于递归调用的返回值res不予考虑，仅考虑最顶层的res。但是如果将res声明为全局变量的时候，res可能被重复赋值（最深的一个递归返回时，i=k，不再深入递归，res赋值一次；在所有递归完毕后，返回到最浅的一层递归时，执行一次res赋值），进而导致出错。 

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        // if(k >= arr.size)return arr;
        return quick_sort(arr, k, 0, arr.size() - 1);
    }

private:
    vector<int> quick_sort(vector<int>& arr, int& k, int low, int high)
    {
        vector<int> res;
        if(low >= high)return res;
        
        int i = low, j = high;
        int pivot = arr[low];
        while(i < j)
        {
            while(i < j && arr[j] > pivot)j--;
            if(i < j)arr[i++] = arr[j];

            while(i < j && arr[i] < pivot)i++;
            if(i < j)arr[j--] = arr[i];
        }
        arr[i] = pivot;

        // 只要i！=k一直进行如下递归
        // 要找的最小的k个数字在pivot左侧
        if(i > k)quick_sort(arr, k, low, i - 1);
        // 要找的最大的k个数字在pivot右侧
        if(i < k)quick_sort(arr, k, i + 1, high);// 返回值无效，主要用来“排序”

        // arr一定要是引用类型，因为只有最顶层的（递归前）的返回值才是有用的
        // 经过递归对pivot某一侧进行排序，下标为k的pivot放到最终位置
        // 那么pivot左侧就是要返回的元素，虽然他们不一定有序
        for(int i = 0; i < k; i++)res.emplace_back(arr[i]);
        return res;
    }
};

3、复杂度分析

🚚 sort 快速排序

时间复杂度：O(nlogn)；

空间复杂度：O(logn)。快排

🚚 基于快速排序的数组划分

时间复杂度：O(n)；因此平均情况下，哨兵划分操作一共有n + n/2 + n/4 + ... + n/n = 2n−1 （等比数列求和），即总体时间复杂度为 O(n) 。

空间复杂度：O(logn)。 划分函数的平均递归深度为 O(logn) 。

4、运行结果

🚚 sort 快速排序

 🚚 基于快速排序的数组划分