优选算法——分治（快排）

1. 颜色分类

题目链接：75. 颜色分类 - 力扣（LeetCode）

题目展示：

题目分析：本题其实就要将数组最终分成3块儿，这也是后面快排的优化思路，具体大家来看下图。

这里我们上来先定义了3个指针，大家要注意3个指针的作用，3个指针在移动的过程中会将数组分成4部分，每一部分都有固定的性质，3个指针移动的过程中，保证指定部分的性质不变，就可以实现最终的结果。

当扫描到0的时候，我们要保证[0,left]区间全是0，那么我们先将left指针向前移动一步，然后将该位置的值与i位置的值进行交换，然后让i向后移动一步；

当扫描到1时，要保证[left,i-1]区间全为1，那么直接让i++即可；

当扫描到2时，我们要保证[right,n-1]区间全为2，那么首先right指针要先往左移动一步，然后将该位置的值与i位置的值进行交换，这里注意不能让i++，因为i一旦往后移动，待扫描的元素就会被跳过。

代码实现：

class Solution {
public:
    void sortColors(vector<int>& nums) 
    {
        int n=nums.size();
        int left=-1;
        int right=n;
        int i=0;
        while(i<right)
        {
            if(nums[i]==0)
            {
                swap(nums[++left],nums[i++]);
            }
            else if(nums[i]==1)
            {
                i++;
            }
            else
            {
                swap(nums[--right],nums[i]);
            }
        }
    }
};

2. 快速排序

题目链接：912. 排序数组 - 力扣（LeetCode）

题目展示：

题目分析：

这里我们要采用数组分三段的方式来实现快排，这是一种比较优秀的方法，可以将快排的效率接近于O(NlogN)。

代码实现：

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        srand(time(NULL));//种下随机数种子
        qsort(nums,0,nums.size()-1);
        return nums;    
    }
    void qsort(vector<int>& nums,int l,int r)
    {
        if(l>=r)
        {
            return;
        }
        //数组分三块儿
        int key=getRandom(nums,l,r);
        int i=l;
        int left=l-1;
        int 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]);
            }
        }
        //[1,left][left+1,right-1][right,r]
        qsort(nums,l,left);
        qsort(nums,right,r);
    }
    int getRandom(vector<int>& nums,int left,int right)
    {
        int r = rand();
        return nums[r%(right-left+1)+left];
    }
};

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

题目链接：215. 数组中的第K个最大元素 - 力扣（LeetCode）

题目展示：

题目分析：本题其实就是TOP-K问题，关于TOP-K问题，我们可以使用堆来解决，但是使用堆，时间复杂度为O(NlogN)；本题要求时间复杂度为O(n)，我们要利用快速选择算法来解决。

代码实现：

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        srand(time(NULL));
        return qsort(nums,0,nums.size()-1,k);
    }
    int qsort(vector<int>& nums,int l,int r,int k)
    {
        if(l==r)
        {
            return nums[l];
        }
        int key=getrandom(nums,l,r);
        int i=l;
        int left=l-1;
        int 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-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 left,int right)
    {
        return nums[rand()%(right-left+1)+left];
    }
};

4. 库存管理（最小的K个数）

题目链接：LCR 159. 库存管理 III - 力扣（LeetCode）

题目展示：

题目分析：本题和上一题其实是类似的，稍微变化了一下，这次我们要返回的是一个数组。

代码实现：

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt) 
    {
        srand(time(NULL));
        qsort(stock,0,stock.size()-1,cnt);
        return {stock.begin(),stock.begin()+cnt};
    }
    void qsort(vector<int>& stock,int l,int r, int cnt)
    {
        if(l>=r)
        {
            return;
        }
        int key=getrandom(stock,l,r);
        int i=l;
        int left=l-1;
        int right=r+1;
        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;
        int b=right-left-1;
        if(a>cnt)
        {
            return qsort(stock,l,left,cnt);
        }
        else if(a+b>=cnt)
        {
            return;
        }
        else
        {
            return qsort(stock,right,r,cnt-a-b);
        }
    }
    int getrandom(vector<int>& stock,int left,int right)
    {
        return stock[rand()%(right-left+1)+left];
    }
};