优选算法的妙思之流：分治——快排专题

专栏：算法的魔法世界

个人主页：手握风云

一、快速排序

二、例题讲解

[2.1. 颜色分类](#2.1. 颜色分类)

[2.2. 排序数组](#2.2. 排序数组)

[2.3. 数组中的第K个最大元素](#2.3. 数组中的第K个最大元素)

[2.4. 库存管理 III](#2.4. 库存管理 III)

一、快速排序

分治，简单理解为"分而治之"，将一个大问题划分为若干个子问题，直到这个子问题能够快速解决。我们之前的快速排序是选出一个数作为基准值，然后将一个数组划分为两个子序列，一个序列<=基准值，另一个>基准值。但这种算法在数据特别大的时候是会超时的。所以我们这里要使用更优秀的三块划分和随机选择基准元素的算法。

二、例题讲解

2.1. 颜色分类

这道题我们可以参照移动零里面的划分策略。移动零里面是利用双指针将数组分为0区域和非0区域，这道题我们也可以使用三个指针left、right、i来将其划分为0、1、2区域。其中i用来遍历数组，left用来标记0区域的最右侧，right用来标记2区域的最左侧。

接下来进行分类讨论：如果nums[i]=0，我们让nums[left+1]与nums[i]进行交换，然后i++，left++，就能保证[left+1,i-1]区间还都是1，还可能有一种极端情况，就是i=left+1，自身与自身进行交换，还是得需要left和i++，综上我们就可以写成nums[++left]与nums[i++]进行交换。如果nums[i]=1，我们直接就可以i++就可以。如果nums[i]=2时，right的移动也可以参照上面left的处理，--right，但i不能++，因为i右侧是未遍历的区间，如果i++，就会跳过这个元素。当i=right时，结束循环。

完整代码实现：

java 复制代码

class Solution {
    public void sortColors(int[] nums) {
        int left = -1, right = nums.length, i = 0;

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

    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

2.2. 排序数组

这道题如果我们直接采用之前的快排思想是会超时的，因为如果数组里的元素都等于基准值key，这样数组元素就会跑到数组的最右侧，导致时间复杂度会退化成。

我们接下来利用数组分三块的思想，将其划分为3个区域，<=key，=key，>=key。这样当基准值都等于key时，时间复杂度直接降为。

接下来就是如何随机选择基准值。我们需要在数组下标中等概率地选择一个下标，那么我们就可以利用随机数种子，利用公式r%(right-left+1)+left求出随机下标。

完整代码实现：

java 复制代码

class Solution {
    public int[] sortArray(int[] nums) {
        Quicksort(nums, 0, nums.length - 1);
        return nums;
    }

    private void Quicksort(int[] nums, int l, int r) {
        if (l >= r) return;//作为递归结束的条件

        //数组分三块
        int key = nums[new Random().nextInt(r - l + 1) + l];
        int left = l - 1, right = r + 1, i = l;
        while (i < right) {
            if (nums[i] < key) swap(nums, ++left, i++);
            else if (nums[i] == key) i++;
            else if (nums[i] > key) swap(nums, --right, i);
        }
        Quicksort(nums, l, left);
        Quicksort(nums, right, r);
    }

    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

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

因为这道题让我们用时间复杂度为，所以我们的思路很明显要使用快速选择排序，也就是上一题的数组分三块与随机选择基准元素。那么这个第K大的元素就有可能落在三个区域内，我们设三个区域的元素个数分别为a、b、c。如果c>=k，那我们就直接去>key的这个区域去寻找；如果b+c>=k，就直接返回key；如果前两个都不成立，就去<key这个区间去寻找第k-b-c大的元素。

完整代码实现：

java 复制代码

class Solution {
    public int findKthLargest(int[] nums, int k) {
        return Quicksort(nums, 0, nums.length - 1, k);
    }

    private int Quicksort(int[] nums, int l, int r, int k) {
        if (l == r) return nums[l];

        //随机选择基准元素
        int key = nums[new Random().nextInt(r - l + 1) + l];

        //根据基准元素，把数组分为三块
        int left = l - 1, right = r + 1, i = l;
        while (i < right) {
            if (nums[i] < key) swap(nums, ++left, i++);
            else if (nums[i] == key) i++;
            else if (nums[i] > key) swap(nums, --right, i);
        }

        //分类讨论
        //区间:[l,left],[left+1,right-1],[right,r]
        int b = right - left - 1, c = r - right + 1;
        if (c >= k) return Quicksort(nums, right, r, k);
        else if (b + c >= k) return key;
        else return Quicksort(nums, l, left, k - b - c);
    }

    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

2.4. 库存管理 III

题目就是求数组中的最小的cnt个数。第一种解法，可以使用Arrays.sort()方法来对数组进行排序，找出前k个元素；第二种解法，利用大根堆，创建一个大小为k的大根堆，将数组的前k个元素丢进大根堆中，然后再将数组剩余的元素与堆顶元素比较，如果小就交换并调整堆，最后堆里面就是最小的k个数；第三个解法，就是快速选择算法。第一种解法的时间复杂度为，第二种解法的时间复杂度为，第三中解法的时间复杂度为。

按照上一题的思路，将数组分为三块，三个区间内元素的个数分别为a、b、c。如果a>cnt，那么我们只需要去<key的区间去寻找；如果a+b>=cnt，此时的cnt一定是大于a的，那么最小的cnt个数，一定位于左侧两个区间，而中间区间又都是等于key的，所以不需要递归，直接++；如果前两个都不成立，直接去最右侧的区间去寻找第cnt-a-b个元素。

完整代码实现：

java 复制代码

class Solution {
    public int[] inventoryManagement(int[] stock, int cnt) {
        Quicksort(stock,0,stock.length - 1,cnt);
        int[] ret = new int[cnt];
        for (int i = 0; i < cnt; i++) {
            ret[i] = stock[i];
        }
        return ret;
    }

    private void Quicksort(int[] nums, int l, int r, int k) {
        if(l >= r) return;

        //随机获取基准元素
        int key = nums[new Random().nextInt(r - l + 1) + l];
        int left = l - 1,right = r + 1,i = l;

        //数组分三块
        while(i < right){
            if(nums[i] < key) swap(nums,++left,i++);
            else if (nums[i] == key) i++;
            else if (nums[i] > key) swap(nums,--right,i);
        }

        //分类讨论
        int a = left - l + 1,b = right - left - 1;
        if(a > k) Quicksort(nums,l,left,k);
        else if (a + b >= k) return;
        else Quicksort(nums,right,r,k - a - b);
    }

    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}