hot100 数组中的第K个最大元素(215)

本题采用随机化快速选择算法（又称"双指针物理划分剪枝法"）解决无序数组中的特定顺序统计量检索问题。其核心本质是利用快速排序的划分机制将全量排序转化为单侧区间收敛，并通过随机化基准值选取规避极端恶劣数据的拓扑退化。当前提供的源码实现了在期望时间复杂度 O(n) 和额外空间复杂度 O(1) 条件下的全局状态收敛，最终走向是精准锁定并返回目标位置上的物理数值。

一、 问题本质与数据模型

对于给定的无序整数数组 nums，题目要求检索出排序后的第 k 个最大元素。该问题面临着核心的时空效率抉择：

• 避免全量无谓排序：常规的排序算法（如快排、归并）会强制使全图所有元素进入有序状态，这在仅索取单点数值的场景下产生了大量的算力冗余。

• 位置对齐映射模型 ：在长度为 n 的升序序列中，"第 k 个最大元素"在物理下标上严格等价于"第 n - k 个最小元素"。基于此，算法引入了全局目标锚点 targetIndex = nums.length - k。

为了在不打乱全量数据的前提下精确定位该锚点，算法引入了"快速选择（Quickselect）分治模型"。其核心机制借用了快速排序的 partition（划分）操作：每次选定一个基准值（pivot），通过双指针碰撞将数组重组为左侧小于基准值、右侧大于基准值的左右两个子弹道。

此时，基准值所在的最终物理下标 i 被唯一锁定。与快排双侧并行递归不同，快速选择展现出极强的剪枝特性：

1. 若 i 恰好等于 targetIndex，直接命中退出；

2. 若 i 小于 targetIndex，说明目标点隐藏在右侧子区间，左侧子区间被完全物理剪枝；

3. 若 i 大于 targetIndex，说明目标点隐藏在左侧子区间，右侧子区间被完全物理剪枝。

每轮更迭平均能物理消除一半的搜索空间，使多轮迭代的整体规模呈现出等比数列收敛的物理特征。

二、 算法演进对比

在解决无序序列特定顺序统计量（中位数/第 K 大）的场景中，快速选择法在时间与空间的资源平衡性上达到了理论极限：

解法名称	时间复杂度	空间复杂度	核心原理	物理瓶颈 / 缺陷
全局排序法 (Arrays.sort)	O(n log n)	O(log n)	对整个数组执行双轴快排，随后通过索引直接定位目标位置	做了大量与最终目标无关的冗余排序，未利用只求单点的局部特征
优先队列法 (小顶堆)	O(n log k)	O(k)	维护一个大小为 k 的小顶堆，遍历数组动态淘汰堆顶小值	需要额外的堆内存空间，且在 n 极大且 k 接近 n 时时间开销退化
快速选择法（当前解法）	期望 O(n)，最坏 O(n^2)	O(1)	结合随机基准值进行单侧剪枝，每轮平均消除一半的搜索空间	最坏情况下（若未采用随机基准）会退化至平方阶，且高度依赖随机数发生器性能

三、 核心分支控制逻辑与决策证明

当前源码的控制流完全依赖于 while (true) 驱动的区间收敛网络与双指针双向划分函数 partition，其内部决策分支证明如下：

1. 目标区间动态裁剪分支

• 执行：

  • 若 i == targetIndex，直接返回 nums[i]；

  • 若 i < targetIndex，执行 left = i + 1；

  • 若 i > targetIndex，执行 right = i - 1。

• 数学证明 ：partition 函数返回的下标 i 是基准值在全局有序状态下的绝对绝对正确位置。若 i < targetIndex，由于左区间 [left, i] 内的所有元素均小于或等于 nums[i]，它们必然严格小于目标锚点处的数值，因此将左边界右移至 i + 1 是绝对安全的空间物理剪枝。

2. 随机化基准值防退化：random.nextInt(left, right + 1)

• 执行：在当前有效区间内随机挑选一个元素作为 pivot。

• 数学证明：若固定选择区间首元素作为基准，在面对已经严格有序或严格逆序的恶劣输入时，每次划分只能切分出 1 个元素，导致空间收敛失效，时间复杂度退化至平方阶 O(n^2)。引入随机扰动后，算法选中良好划分点的概率得到数学保障，将最坏情况转化为极小概率事件，从而将期望时间复杂度锚定在 O(n)。

3. 双指针双向物理划分：while (i <= j && nums[i] < pivot) ...

• 执行 ：头尾双指针向中间靠拢，不满足单调性的元素执行 swap(nums, i, j)。

• 数学证明 ：此处的双向指针设计具备极强的稳定性。通过 nums[i] < pivot 与 nums[j] > pivot 的严格不等式判定，强制使等于 pivot 的元素在遭遇不满足时触发互换。这种设计在面对包含大量重复元素的极端矩阵（如全相同数组）时，能物理迫使指针在几何中心交汇，杜绝了划分严重倾斜的风险。

四、 算法执行状态机步进示例

以输入数组 nums = [3, 2, 1, 5, 6, 4]，k = 2 为例（规模 n = 6，目标锚点 targetIndex = 6 - 2 = 4）。模拟状态机演进如下（注：假定随机数选取的物理演进路径）：

步骤	当前搜索闭区间 left, right	随机选取的基准值物理数值 (及索引)	partition 划分后的数组状态	返回的绝对索引 i	执行的剪枝控制流动作
初始	0, 5	3 (当前索引 0)	1, 2, 3, 5, 6, 4	2	2 < 4，命中较小分支，执行 left = 2 + 1 = 3
1	3, 5	5 (当前索引 3，原数组值为 5)	1, 2, 3, 4, 5, 6	4	4 == 4，命中目标分支，直接终止循环
终止	-	-	-	-	成功向外层返回 nums[4] 的数值 5

五、 源码实现

import java.util.Random;

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int left = 0;
        int right = nums.length - 1;
        // 核心控制：将第 k 个最大元素映射为升序数组中的绝对物理目标下标
        int targetIndex = nums.length - k;
        
        // 状态机循环：在区间未收敛至单点前持续进行单侧裁剪搜索
        while (true) {
            // 对当前区间执行物理划分，获取基准值的绝对有序下标 i
            int i = partition(nums, left, right);
            
            // 条件分支 1：命中目标锚点，直接返回结果
            if (i == targetIndex) {
                return nums[i];
            } 
            // 条件分支 2：当前索引位于目标左侧，裁剪左子区间，向右收敛
            else if (i < targetIndex) {
                left = i + 1;
            } 
            // 条件分支 3：当前索引位于目标右侧，裁剪右子区间，向左收敛
            else {
                right = i - 1;
            }
        }
    }

    // 引入伪随机数发生器，用于破坏输入数据的恶劣单调性
    private static final Random random = new Random();

    private int partition(int[] nums, int left, int right) {
        // 核心安全机制：在 [left, right] 闭区间内随机选取一个基准值索引
        int i = random.nextInt(left, right + 1);
        int pivot = nums[i];
        
        int j = right;
        // 将选中的基准值强行交换至区间最左端，腾出探测空间
        swap(nums, i, left);
        
        // 初始化左探测指针（从基准右侧一步出发）与右探测指针
        i = left + 1;
        
        // 双指针物理碰撞状态机
        while (true) {
            // 左指针右移：跳过所有严格小于基准值的元素
            while (i <= j && nums[i] < pivot) {
                i++;
            }
            // 右指针左移：跳过所有严格大于基准值的元素
            while (i <= j && nums[j] > pivot) {
                j--;
            }
            // 终止判定：若两指针发生物理交错，说明全区间划分完毕，跳出碰撞
            if (i > j) {
                break;
            }
            // 逆序对修正：交换两侧违规元素，随后各自步进向前
            swap(nums, i, j);
            i++;
            j--;
        }
        
        // 基准归位：将暂存在最左端的基准值与右指针 j 所在位置的元素对调
        swap(nums, left, j);
        // 返回基准值最终被唯一锁定的绝对正确下标
        return j;
    }

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

六、 复杂度分析

1. 时间复杂度：期望 O(n)

• 分析 ：在进行 partition 划分时，需要对当前区间的物理元素进行单次全盘扫描，耗时与当前区间长度成正比。在引入随机化基准值的前提下，每轮划分期望能够将问题规模均等切分。因此，整体处理的元素总规模构成一个级数序列：n + n/2 + n/4 + n/8 + ... 。根据等比序列求和公式，该无穷级数的最终收敛值严格等于 2n。

• 结论：算法的基本比对与交换操作的总步数与 n 呈纯粹的线性对应关系，期望时间复杂度为 O(n)。最坏情况下（极小概率每轮都选到最值），时间复杂度为 O(n^2)。

2. 空间复杂度：O(1)

• 分析 ：当前源码将传统的快排递归架构改写为了纯粹的迭代 while (true) 结构。这种架构直接消除了隐式方法调用栈的空间占用。在算法运行期间，仅在栈内存中开辟了诸如 left、right、i、j 等常数个基础类型的局部控制变量。

• 结论：算法未申请任何与输入规模成正比的外部独立数据结构，额外空间开销恒定为常数阶 O(1)。