[Lc7_分治-快排] 快速选择排序 | 数组中的第K个最大元素

本文链接：https://blog.csdn.net/2301_80171004/article/details/146123800

1. 数组中的第K个最大元素

题目链接：215. 数组中的第K个最大元素

题目分析：

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:

输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

其实就是一个TopK问题。

TopK问题四种问法：

第 k 个最大的元素✔️
第 k 个最小的元素
前 k 个最大的元素
前 k 个最小的元素✔️

可以使用堆排序，时间复杂度O(nlogn)

还有一种就是快速选择算法，快速选择算法是基于快排实现的。时间复杂度O(n)。

题解

一定要把数组分三块+随机选择基准元素掌握，才能懂这道题。

核心操作还是选择一个基准元素key，将数组分成< key ， = key ，> key 三块区域。
在这道题中我们是要找到第K大元素，这个第K大元素有可能落在三个区域中的任何一个区域。
如果有一种方法能够确定第K大元素能够落在那个区域，那另外两个区域就不用考虑了。
仅需在确定的区域里面递归找。所以说它是比快排更快的一种算法。

接下来重点就是如何确定第K大元素落在左边区域、中间区域、还是右边区域。

此时我们先统计出每个区域中元素的个数，假设左边区域元素个数为 a，中间区域元素个数为 b，右边区域元素个数为 c。

此时就分三种情况讨论：

因为求第K大，所以可以先考虑右边区域
因为右边区域都是大元素聚集地，第K大最有可能在右边区域。

第一种情况：

如果第K大是落在右边区域，此时 c >= K（例如 c 为前 5 大，K 为找出第三大的）
因为c表示大元素有多少个，而K表示找第K大的元素。如果 c >= K ，那第K大一定是落在右边区域。
此时我们仅需到[right，r]，找第K大。

第二种情况：

如果到了第二情况那第一种情况一定是不成立的。
如果第K大是落在中间区域，此时 b + c >= K，又因为第一种情况不满足，所有第K大一定是落在中间区域。
此时就找到了也不用递归了。直接返回就可以。

第三种情况：

第一、第二种情况全部不成立，第K大一定落在左边区域，去[l，left]找
但是此时并不是去找第K大了，本来是想在整个区间找第K大，但是第K大元素确定不在中间区域和右边区域，中间和右边区域都要被抛弃
此时去找左边区间找的是第 K - b - c 大的元素

代码

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        int n=nums.size();
        srand((unsigned int)time(nullptr));
        return QuickSort(nums,0,n-1,k);
    }

    int QuickSort(vector<int>& nums,int l,int r,int k)
    {
        if(l==r) return nums[l];
        //!!!!!!!递归的 终止情况

        int key=nums[rand()%(r-l+1)+l];

        int i=l,left=l-1,right=r+1;//初始化在 区间边界之外

        while(i<right)
        {
            if(nums[i]<key)
                swap(nums[++left],nums[i++]);
            else if(nums[i]==key)
                i++;
            else
                swap(nums[--right],nums[i]);
        }
        int c=r-right+1;
        int b=right-1-left;

        if(c>=k)
            return QuickSort(nums,right,r,k);
        else if(b+c>=k && c<k)
            return key;
        else 
            return QuickSort(nums,l,left,(k-b-c));//return调用递归
    }

};

2.库存管理 III

题目链接：LCR 159. 库存管理 III

题目分析：

仓库管理员以数组 stock 形式记录商品库存表，其中 stock[i] 表示对应商品库存余量。请返回库存余量最少的 cnt 个商品余量，返回 顺序不限。

示例 1：

输入：stock = [2,5,7,4], cnt = 1
输出：[2]

示例 2：

输入：stock = [0,2,3,6], cnt = 2
输出：[0,2] 或 [2,0]

即前面说到的返回前 k 小的元素

实际上这也是一个TopK问题，让找前K个最小元素。注意返回结果并不考虑顺序问题。

算法原理：

解法一：排序，时间复杂度O(nlogn)
解法二：堆，时间复杂度O(nlogk)
解法三：快速选择算法，时间复杂度O(n)

数组分三块+随机选择基准元素。

选择一个基准元素key，将数组分成< key ， = key ，> key 三块区域。找前K个最小的元素，落在三个区域中任何一个。

统计除每个区域元素个数，然后选择去那个区域找。

分三种情况：

因为前K下最小元素最有可能出现在左边区域，因此先判断左边区域
a >= K ，去[l，left] 找前K个最小元素
b + a >= K ，直接返回
1、2都不成立，去[right，r] 找 K - a - b 个最小元素

代码

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt) 
    {
        int n=stock.size();
        srand((unsigned int)time(nullptr));
        if(cnt==0) return {};
        return QuickSort(stock,0,n-1,cnt);
    }

    vector<int> QuickSort(vector<int>& nums,int l,int r,int k)
    {
//1.
        if(l >= r) return {nums[l]}; // 基础case返回单元素

        int key=nums[rand()%(r-l+1)+l];
        //快排
        int i=l,left=l-1,right=r+1;


        while(i<right)
        {
            if(nums[i]<key)
                swap(nums[++left],nums[i++]);
            else if(nums[i]==key)
                i++;
            else    
                swap(nums[--right],nums[i]);
        }

        int a=left-l+1;
        int b=right-1-left;

        if(a>=k)
            return QuickSort(nums,l,left,k);
         else if(a + b >= k) 
            return vector<int>(nums.begin()+l, nums.begin()+l+k); 
            // 直接取前k个

         else 
         {
            vector<int> res(nums.begin()+l, nums.begin()+right); 
            // 全取左&等于段
            vector<int> rightRes = QuickSort(nums, right, r, k - a - b);
            res.insert(res.end(), rightRes.begin(), rightRes.end());
            return res;
        }
    }
};

返回前 k 个元素，在返回第 K 个元素基础上，做的嵌套改动