快排算法模板and两道值得细品的快排算法题--力扣215、LCR159

目录

快排算法模板：

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

1.2题目描述：

1.3解法：

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

2.2题目描述：

2.3解法：

---

快排算法模板：

vector<int> sortArray(vector<int>& nums) {
    srand(time(NULL));//随机生成一个随机数种子
    quicksort(nums, 0, nums.size() - 1);
    return nums;    
    }

    void quicksort(vector<int>& nums, int l, int r)
    {
        if(l >= r) return;
        //数组分三块
        int key = GetRandom(nums,l,r);
        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]);
        }
        //[l,left][left+1, right-1][right, r]
        quicksort(nums,l,left);
        quicksort(nums,right,r);
    }

    int GetRandom(vector<int>& nums,int left,int right)
    {
        int r = rand();
        return nums[r%(right - left + 1)+left];
    }

1. 传统快速排序的瓶颈

传统快速排序通过基准值将数组分为两部分：小于基准和大于等于基准。当数组中存在大量重复元素时，这种划分会导致递归树极度不平衡，时间复杂度退化为 O(n^2)。例如，若所有元素相同，每次划分仅减少一个元素，需要递归 n 层。

2. 三路划分的核心思想

三路划分将数组分为三部分：

• 小于基准：arr[left:lt]arr[left:lt]
• 等于基准：arr[lt:gt]arr[lt:gt]
• 大于基准：arr[gt:right]arr[gt:right]

通过这种方式，等于基准的元素不再参与后续递归，仅需处理小于和大于部分，大幅减少递归深度。例如，若数组中有 k 个重复的基准值，传统方法需递归处理 n−k 个元素，而三路划分直接跳过中间段。

3. 随机数选择基准的作用

随机选择基准（而非固定选择首/尾元素）避免输入有序导致的最坏情况。数学证明表明，随机化后快速排序的期望时间复杂度为 O(nlog⁡n)。例如，在有序数组中随机选基准，划分后左右子数组长度的期望趋于平衡。

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

1.2题目描述：
 

给定整数数组 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

提示：

• 1 <= k <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4

1.3解法：

算法思路：

在快排中，当我们把数组分成三块之后：[l,left][left+1,right-1][right,r]，我们可以通过计算每一个区间内元素的个数，进而推断我们要找的元素是在哪一个区间里面。

那么我们可以直接去相应的区间去寻找最终结果就好了。

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        srand(time(NULL));
        int n = nums.size();
        int left = 0,right = n-1;
        return qsort(nums,left,right,k);
    }
    int qsort(vector<int>& nums,int l,int r,int k)
    {
        if(l==r)return nums[l];
        //1.随机选择基准元素
        int key = GetRandom(nums,l,r);
        //2.根据基准元素将数组分三块
        int left = l-1,right = r+1;
        int i = l;
        while(i<right)
        {
            if(nums[i]<key)swap(nums[++left],nums[i++]);
            else if(nums[i]>key)swap(nums[--right],nums[i]);
            else i++;
        }
        //3.分情况讨论
        int c = r-right+1, b = right-left-1; 
        if(c>=k) return qsort(nums,right,r,k);
        else if(b+c>=k) return key;
        else return qsort(nums,l,left,k-b-c);
    }
    
    int GetRandom(vector<int>& nums,int l,int r)
    {
        int k = rand();
        return nums[k%(r-l+1)+l];
    }
};

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

2.2题目描述：

仓库管理员以数组 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]

提示：

• 0 <= cnt <= stock.length <= 10000
0 <= stock[i] <= 10000

2.3解法：

算法思路：

在快排中，当我们把数组分成三块之后：[l, left][left+1, right-1][right, r]，我们可以通过计算每一个区间内元素的个数，进而推断出最小的k个数在哪些区间里面。

那么我们可以直接去相应的区间继续划分数组即可。

和上面那题的思路其实是相同了，能理解上面那道题，这题就可以轻松解决了

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt) {
        srand(time(NULL));
        qsort(stock,0,stock.size()-1,cnt);
        
        return vector<int>(stock.begin(),stock.begin()+cnt);
    }

    void qsort(vector<int>& stock,int l, int r,int k)
    {
        if(l>=r)return;

        int key = GetRandom(stock,l,r);

        int left = l-1,right = r+1,i=l;
        while(i<right)
        {
            if(stock[i]<key)swap(stock[++left],stock[i++]);
            else if(stock[i]==key)i++;
            else swap(stock[--right],stock[i]);
        }
        int a = left-l+1,b = right-left-1;
        if(a>k) qsort(stock,l,left,k);
        else if(a+b>=k) return;
        else qsort(stock,right,r,k-a-b);

    }
    int GetRandom(vector<int>& stock,int l, int r)
    {
        return stock[rand()%(r-l+1)+l];
    }
};