Java算法精讲：215.数组中的第K个最大元素_数组中的第k个最大元素 java-优快云博客

本文链接：https://blog.youkuaiyun.com/Liamk_super/article/details/147008149

本讲涉及算法点：（1）计数排序（2）数组、分治(partition)、快速选择

先贴个题目链接，大家可以先尝试一下：215. 数组中的第K个最大元素 - 力扣（LeetCode）

第一眼看到这个题目，相信大家肯定首先想到的就是排序+取k下标元素，但是Java标准库中的中自带的Arrays.sort()的时间复杂度为 O(n*logn) ，明显不符合题目 O(n) 的要求。

所以本文主要会讲两种算法，一种是桶排序，一种是快速选择。

解法一：计数排序

当看到题目中数组长度和元素大小是有范围的时候，可以考虑计数排序。

我们先创建一个容量数组≥元素大小的数组（此处为2 * 10^5），然后遍历数组，统计每个数字出现的次数。最后倒序遍历，找到最大的k个元素所在位置。这里有个比较巧妙的点，当k的值≤bucket[i]的值，说明此时的要找的元素就为bucket[i]。举个例子，45556，k=2，此时目标元素就是5，而不用去关心到底是哪个5。

// 解法一：计数排序
class Solution {
    public int findKthLargest(int[] nums, int k) {
        int[] bucket = new int[200002];
        for(int i = 0; i < nums.length; i++) {
            bucket[nums[i] + 100000]++;
        }
        for(int i = 200000; i >= 0; i--) {
            if(bucket[i] >= k) {
                return i - 100000;
            }
            k -= bucket[i];
        }
        return -1;
    }
}

解法二：快速选择

虽然解法一浅显易懂，但面试官出这一题，可能就是想考你对快速排序算法的理解，如果让你换个解法，那不是GG了~ 所以这道题还必须要会解法二，也就是快速选择。解法二比起解法一会复杂一些。大家集中精神，我们继续🕶

在讲解一开始，我提到：大家可能会想到用库函数来做。但这不是出题的目的，于是会想到自己实现一个快速排序（选取一个基准元素p，小于p的放在左边，大于p的放在右边，递归地排序下去），这种算法对于随机数据来说复杂度为 O(n * logn) ，但如果遇到特殊情况（顺序 / 逆序数组），递归树会直接退化成链表，时间复杂度就来到了 O(n^2) 【因为每次选择的p都是最大 / 最小值】。所以我们需要使用另一种算法，叫快速选择。

快速选择基于快速排序，可以通过一次遍历，确定一个元素在排序之后的位置。这个元素左侧的元素值均≤它自己，右侧的元素值均≥它自己。在此题中，我们并不需要把所有元素都排序完后再去找第k大的元素，符合快速选择的思想。

注：这里必须随机初始化pivot元素，因为测试用例有极端数据，所以我们要随机交换第1个元素和它后面任意一个元素的位置。

// 解法二：快速选择
class Solution {
    
    private static final Random random = new Random();

    public int findKthLargest(int[] nums, int k) {
        int n = nums.length;
        // 计算目标位置：排序后数组中第k大元素的下标
        int target = n - k;
        // 初始化搜索区间为整个数组
        int left = 0, right = n - 1;

        // 快速选择主循环
        while(true) {
            // 对当前区间进行分区，返回基准元素的最终位置
            int index = partition(nums, left, right);
            
            if(index == target) {
                // 找到目标元素
                return nums[index];
            } else if(index < target) {
                // 目标在右半区，调整左边界
                left = index + 1;
            } else {
                // 目标在左半区，调整右边界
                right = index - 1;
            }
        }
    }

    /**
     * 分区函数：将数组分为两部分，左边<=基准值，右边>=基准值
     */
    private int partition(int[] nums, int left, int right) {
        // 随机选择基准元素，避免最坏情况
        int randomIndex = left + random.nextInt(right - left + 1);
        // 将基准元素交换到左边界
        swap(nums, left, randomIndex);

        // 基准值
        int pivot = nums[left];
        // 左指针：从左向右扫描，找第一个>=pivot的元素
        int leftP = left + 1;
        // 右指针：从右向左扫描，找第一个<=pivot的元素
        int rightP = right;
        
        // 双指针扫描循环
        while(true) {
            // 移动左指针，跳过所有<pivot的元素
            while(leftP <= rightP && nums[leftP] < pivot) leftP++;
            // 移动右指针，跳过所有>pivot的元素
            while(leftP <= rightP && nums[rightP] > pivot) rightP--;
            
            // 指针相遇或交叉时终止循环
            if(leftP >= rightP) break;
            
            // 交换左右指针位置的元素（≤pivot的放左边，≥pivot放右边）
            swap(nums, leftP, rightP);
            // 移动指针继续扫描
            leftP++;
            rightP--;
        }
        
        // 将基准值放到（原本该在的）最终位置，因为leftP可能会大于前面的元素，所以不选择
        swap(nums, left, rightP);
        // 返回基准值的最终位置
        return rightP;
    }

    /**
     * 交换数组中两个位置的元素
     */
    private void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }
}

为什么partition方法最后要交换的是右指针而不是左指针呢？因为有两种情况：①左指针和右指针指向同一个元素 ②右指针指向左指针左边一个元素的位置。在①中，返回左右指针都可以，但在②中，左指针是≥右指针的，此时如果交换左指针，可能会导致首元素大于后面元素。