2021-5-12 剑指 Offer 40. 最小的k个数（sort，大顶堆，快速排序）

注：
①要用大顶堆而不是小顶堆（思考为什么）。
②priority_queue：push()函数可以对堆进行重新排序，而pop操作不可以。
③快速排序比较大小时要包含等于号，判断边界条件时，不需要包含等于号。

while(i<j&&arr[left]<=arr[j])

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

题解：
方法一 sort
思路和算法
对原数组从小到大排序后取出前 k 个数即可。

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

复杂度分析
时间复杂度：O(nlogn)，其中 n 是数组 arr 的长度。算法的时间复杂度即排序的时间复杂度。
空间复杂度：O(logn)，排序所需额外的空间复杂度为 O(logn)。

方法二 大顶堆
算法思路

1. 先将 arr 的前 k 个数入堆，因为是最大堆，所以堆顶的数一定是最大的。
2. 那么我们再从 arr 的第 k + 1 个元素迭代起，凡是遇到比当前堆顶元素小的，就将该元素 push 入堆并 pop 掉堆顶元素。
3. 注意，每次执行完第二步之后，堆会自动更新，以保证堆顶元素始终为堆中所有元素的最大值。

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        if(k==0){
            return {};
        } 
        priority_queue<int> numqueue;
        vector<int> result;
        //构建一个大小为k的大顶堆
        for(int i=0;i<k;i++){
            numqueue.push(arr[i]);//push()会更新最大堆
        }
        //从k+1开始计算，循环得到数组中最小的k个元素
        for(int i=k;i<arr.size();i++){
            if(arr[i]<=numqueue.top()){
                numqueue.pop();//pop()不会更新最大堆
                numqueue.push(arr[i]);//push()会更新最大堆
            }
        }
        //最后输出大顶堆，即为所求
        for(int i=0;i<k;i++){
            result.push_back(numqueue.top());
            numqueue.pop();
        }
        return result;
    }
};

复杂度分析
时间复杂度：O(nlogk)，其中 n 是数组 arr 的长度。由于大根堆实时维护前 kk 小值，所以插入删除都是 O(logk) 的时间复杂度，最坏情况下数组里 n 个数都会插入，所以一共需要 O(nlogk) 的时间复杂度。
空间复杂度：O(k)，因为大根堆里最多 k 个数。

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

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

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

算法流程
getLeastNumbers() 函数：
若 k 大于数组长度，则直接返回整个数组；
执行并返回 quick_sort() 即可；

quick_sort() 函数：
注意，此时 quick_sort() 的功能不是排序整个数组，而是搜索并返回最小的 k 个数。
哨兵划分：
划分完毕后，基准数为 arr[l] ，左 / 右子数组区间分别为 [l,i−1] , [i + 1, r]；

递归或返回：
若 k<i ，代表第 k + 1小的数字在 左子数组 中，则递归左子数组；
若 k > i ，代表第 k + 1小的数字在 右子数组 中，则递归右子数组；
若 k = i，代表此时 arr[k] 即为第 k + 1小的数字，则直接返回数组前 k 个数字即可；

复杂度分析：
本方法优化时间复杂度的本质是通过判断舍去了不必要的递归（哨兵划分）。
时间复杂度 O(N) ： 其中 N 为数组元素数量；对于长度为 N 的数组执行哨兵划分操作的时间复杂度为 O(N) ；每轮哨兵划分后根据 k 和 i 的大小关系选择递归，由于 i 分布的随机性，则向下递归子数组的平均长度为 N/2；因此平均情况下，哨兵划分操作一共有 N + N/2 + N/4 + … + N/N <2N ，即总体时间复杂度为 O(N) 。
空间复杂度 O(logN) ： 划分函数的平均递归深度为 O(logN) 。

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        //若 k 大于数组长度，则直接返回整个数组；
        if(k>=arr.size()){
            return arr;
        }
        if(k==0){
            return {};
        }
        return quicksort(arr,k,0,arr.size()-1);

    }
    vector<int> quicksort(vector<int>& arr,int k,int left,int right){
        int i=left;//用i来标识基准值的位置
        int j=right;
        //令arr[l]为基准值,循环完成后，i即为arr[left]的位置
        while(i<j){
            while(i<j&&arr[left]<=arr[j]){
                j--;
            }
            while(i<j&&arr[left]>=arr[i]){
                i++;
            }
            swap(arr[i],arr[j]);
        }
        swap(arr[left],arr[i]);
        //若i<k，则代表第 k + 1小的数字在 右子数组 中，则递归右子数组
        if(i<k){
            return quicksort(arr,k,i+1,right);
        }
        //若i>k，则代表第 k + 1小的数字在 左子数组 中，则递归右子数组
        if(i>k){
            return quicksort(arr,k,left,i-1);
        }
        //若i==k，则证明找到了第 k + 1小的数字，其左边即为最小的k个数。
        vector<int> result;
        for(int i=0;i<k;i++){
            result.push_back(arr[i]);
        }
        return result;
    }
};