算法——分治

1. 什么是分治？

分治算法是一种将一个大问题分解成若干个相似而独立的子问题来求解的算法设计策略。通过递归地将问题分解为更小的子问题，然后将子问题的解合并起来，最终得到原始问题的解。

2. 分治中的快排

在这之前我们已经实现过快速排序算法，我们知道快速排序算法的时间复杂度为O(N*logN)，但是在数据完全相同的情况下，快排的时间复杂度会退化成为O(N^2)。

1. 三路划分

我们可以使用数组分三块（三路划分）的思想来优化快速排序，我们使用下面这道题来举例

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

分析这道题目，我们可以发现整个数组到最后会被分成三部分，分别是0的部分，1的部分和2的部分，我们可以定义一个左指针left，一个右指针right，同时再定义一个指针i，用这三个指针将整个数组划分成4个部分，即

在分成了这几个部分后，对于每一次i的情况我们就可以进行分类，即

分析之后我们可以得到如下代码

class Solution 
{
public:
    void sortColors(vector<int>& nums) 
    {
        int n = nums.size();

        int i = 0, left = -1, right = n;
        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）

解析：在这之前我们在快速排序中挑选基准值的方式为三数取中（即取开始、结尾与中间三数中的中间值），而我们可以在数组中随机挑选一个数来作为基准值，rand % (right - left + 1) 来将随机值修正到区间长度内，再+left就能够做到随机挑选，在挑选好基准值后，我们可以将整个数组分为3个部分，即 < key 的部分，== key的部分， > key的部分，我们可以仿照之前颜色划分的思路实现代码，代码如下

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        // start rand(获取随机数快捷记忆)
        srand(time(NULL));
        QuickSort(nums, 0, nums.size()-1);

        return nums;
    }

    void QuickSort(vector<int>& nums, int left, int right)
    {
        // 快排出口
        if (left > right) return;

        // 随机挑选基准值
        int key = nums[ rand() % (right-left+1) + left];

        // 三路划分
        int i = left, l = left-1, r = right + 1;
        while (i < r)
        {
            if (nums[i] < key) swap(nums[++l], nums[i++]);
            else if (nums[i] == key) i++;
            else swap(nums[--r], nums[i]);
        }
        
        // 排序后区间:
        // [left, l] [l+1, r-1] [r, right]
        QuickSort(nums, left, l);
        QuickSort(nums, r, right);
    }
};

 3. 快速选择算法

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

解析：对于这道题我们可以采取堆排序的算法来解决，即

class Solution 
{
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        priority_queue<int> heap;
        for (int e : nums) heap.push(e);

        while (--k) heap.pop();

        return heap.top();     
    }
};

但是堆排序的时间复杂度为O(N*logN)，题目要求的是使用O(N)的算法，在这里我们介绍一个快速选择算法，其时间复杂度为O(N)，这在《算法导论》这本书中给出了详细的证明（代码后会贴出），对于这道题的基本想法还是先使用三路划分基于一个key值将数组分为三个部分，然后分别使用a, b. c来统计 < key, == key, > key区域的个数，若 c >= k 则表明 > key区域中的元素包含有第K个最大元素，此时再递归到c区域中找寻第K个最大元素即可；若 b+c >= key 则表明 > key 的区域中元素没有第K个最大元素，而 == key 的区域中有，此时返回key即可；若不是上述两种情况，则表明 < key 的区域中包含有第K个最大元素，此时需要在a区域中找寻 第K - b - c个最大元素，分析好之后，代码如下

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 = nums[rand() % (r - l + 1) + l];

        int left = l - 1, right = r + 1, i = l;
        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 b = right - left - 1, c = r - right + 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);
    }
};

算法导论证明如下