LeetCode 215. 数组中的第K个最大元素 - 快速选择与堆优化详解

一、文章标题
LeetCode 215. 数组中的第K个最大元素 - 快速选择与堆优化详解

二、文章内容

1. 题目概述

• 题目描述：给定一个未排序的整数数组 nums 和一个整数 k，请你返回数组中第 k 个最大的元素。注意，这是按排序后的位置来定义的第 k 大（第 1 大是最大值），而不是第 k 个不同的元素。要求在尽可能低的时间复杂度下完成。
• 原题链接：https://leetcode.cn/problems/kth-largest-element-in-an-array/
• 难度等级：Medium
• 相关标签：数组、分治、快速选择、堆（优先队列）、排序

2. 文章目录

目录

1. 题目概述
2. 解题思路
3. 算法详解
   • 3.1 解法一：快速选择（Quickselect，随机化分治）
   • 3.2 解法二：小顶堆维护前K大（PriorityQueue）
4. 解法对比
5. 最优解推荐

3. 解题思路

• 问题分析：
  • 输入：一个整型数组 nums，以及整数 k（1 ≤ k ≤ nums.length）。
  • 输出：nums 中第 k 大的元素值。
  • 约束：未排序、可能包含重复值；需在多组数据场景下尽量以 O(n) 或 O(n log k) 完成。
• 核心难点：
  • 在不完全排序整个数组的前提下，快速定位第 k 大位置；
  • 处理重复元素与边界输入（k 越界、空数组等）的鲁棒性；
  • 选择合适的算法在时间与空间之间权衡。
• 解题方向：
  1. 快速选择（Quickselect）：平均 O(n)，原地选择目标位置；通过随机化 pivot 降低最坏情况概率。
  2. 小顶堆（PriorityQueue）：维护大小为 k 的堆，遍历一次得到堆顶即答案，O(n log k)，适合数据流或 k 远小于 n。
  3. 排序基线：整体排序后取第 n-k 位，O(n log n)，实现最简单但不最优，作为基线与对照。

4. 算法详解

解法一：快速选择（Quickselect，随机化分治）

算法原理

• 基于快速排序的思想，通过 partition 操作将数组按某个 pivot 分成两侧：左侧小于 pivot，右侧大于等于 pivot（本文采用升序 partition 以定位索引）。
• 若目标索引 target = n - k（升序后的目标位置），当 partition 返回位置 p：
  • p == target：直接返回 nums[p]；
  • p < target：在右半区继续选择；
  • p > target：在左半区继续选择。
• 随机选择 pivot 将最坏 O(n^2) 的概率降低，平均时间复杂度 O(n)。
• 适用场景：一次性在内存数组中查询第 k 大，追求均摊时间最优。

具体实现

• 步骤1：校验输入，若 nums 为空或 k 越界，安全返回默认值（如 Integer.MIN_VALUE），不抛异常。
• 步骤2：设 target = n - k，使用循环配合随机化 pivot 与 Lomuto 分区法，逐步缩小搜索区间。
• 步骤3：当分区位置等于 target 时返回；若循环结束未命中（理论上不发生），做安全返回。

复杂度分析

• 时间复杂度：平均 O(n)。每次分区期望将问题规模缩小为常数比例，总体期望线性。
• 空间复杂度：O(1)。原地分区，除少量变量外不占额外空间。

Java代码实现

import java.util.Random;

// 解法一：快速选择（随机化分治）
class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 边界与非法入参处理：返回默认值，不抛异常
        if (nums == null || nums.length == 0 || k <= 0 || k > nums.length) {
            return Integer.MIN_VALUE; // 默认返回值，表示无效输入
        }
        int n = nums.length;
        int target = n - k; // 升序后的目标索引
        int left = 0, right = n - 1;
        Random random = new Random();

        while (left <= right) {
            // 在 [left, right] 范围内随机选择一个 pivot
            int pivotIndex = left + random.nextInt(right - left + 1);
            int pivotPos = partition(nums, left, right, pivotIndex);
            if (pivotPos == target) {
                return nums[pivotPos];
            } else if (pivotPos < target) {
                left = pivotPos + 1; // 目标在右侧
            } else {
                right = pivotPos - 1; // 目标在左侧
            }
        }
        // 理论上不会到达此处，返回安全默认值
        return Integer.MIN_VALUE;
    }

    // Lomuto 分区：以 pivot 为基准，将小于 pivot 的放左侧，其余放右侧；返回 pivot 最终位置
    private int partition(int[] a, int left, int right, int pivotIndex) {
        int pivotVal = a[pivotIndex];
        swap(a, pivotIndex, right); // 将 pivot 暂存到末尾
        int store = left;
        for (int i = left; i < right; i++) {
            // 使用 < 使得分区为升序（小的在左），方便用 n-k 作为目标索引
            if (a[i] < pivotVal) {
                swap(a, store, i);
                store++;
            }
        }
        swap(a, store, right); // pivot 放回最终位置
        return store;
    }

    private void swap(int[] a, int i, int j) {
        if (i == j) {
            return; // 避免不必要交换
        }
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
}

---

解法二：小顶堆维护前K大（PriorityQueue）

算法原理

• 使用大小为 k 的小顶堆保存当前遇到的 k 个最大元素。遍历数组：
  • 将当前元素加入堆；
  • 若堆大小超过 k，则弹出堆顶（当前 k+1 个元素中最小的被移除）；
  • 遍历结束，堆顶即为第 k 大元素。
• 适用场景：
  • k 远小于 n，可在 O(n log k) 时间完成；
  • 数据流或无法一次性载入全部数据时，可边读边维护堆。

具体实现

• 步骤1：校验入参，非法时返回默认值。
• 步骤2：创建容量为 k 的 PriorityQueue（Java 默认小顶堆）。
• 步骤3：遍历 nums，将元素入堆并在 size > k 时弹出堆顶，最终返回 peek。

复杂度分析

• 时间复杂度：O(n log k)。每次入堆/出堆为 O(log k)，共 n 次入堆。
• 空间复杂度：O(k)。堆中最多存放 k 个元素。

Java代码实现

import java.util.PriorityQueue;

// 解法二：小顶堆
class SolutionHeap {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0 || k > nums.length) {
            return Integer.MIN_VALUE; // 默认返回值，表示无效输入
        }
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(k);
        for (int x : nums) {
            // 将当前元素加入堆
            minHeap.offer(x);
            // 若超过 k 个，则移除最小的，保持堆大小为 k
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }
        // 此时堆顶即为第 k 大元素
        if (minHeap.size() < k) {
            return Integer.MIN_VALUE; // 安全返回，理论上不会发生
        }
        return minHeap.peek();
    }
}

---

其他：排序基线法（对照）

算法原理

• 直接对数组进行升序排序，返回 nums[n - k] 即可。
• 适用场景：实现简洁、一次性查询、对性能不敏感时作为快速实现或校验基线。

复杂度分析

• 时间复杂度：O(n log n)。受制于排序下限。
• 空间复杂度：O(1) ~ O(n)，取决于所用排序实现与是否原地。

Java代码实现

import java.util.Arrays;

class SolutionSort {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0 || k > nums.length) {
            return Integer.MIN_VALUE; // 默认返回值
        }
        Arrays.sort(nums); // 升序排序
        return nums[nums.length - k];
    }
}

5. 解法对比与总结

解法	时间复杂度	空间复杂度	优点	缺点	适用场景
快速选择	平均 O(n)，最坏 O(n^2)	O(1)	均摊最快、原地、不需额外空间	需实现分区与随机化，最坏情况退化	一次性查询、内存数组、追求性能
小顶堆	O(n log k)	O(k)	实现简单、适合数据流、k≪n 时高效	常数因子略大，需额外空间	数据流/大数据、k 较小、多次在线查询
排序基线	O(n log n)	取决于实现	代码最简、稳定可靠	不最优，整体排序浪费	性能不敏感、快速校验或基线

最优解推荐：综合时间、空间与可读性：

• 若为一次性查询且可随机访问数组，优先推荐“快速选择（随机化）”，期望 O(n)；
• 若 k 远小于 n 或处理数据流，推荐“小顶堆维护前 K 大”，O(n log k)，实现稳健简洁。

三、文章标签
算法,堆,快速选择,分治,排序,优先队列,LeetCode,中等

四、文章简述
本题为选择类问题，目标找出数组第K大元素。文章详解快速选择（随机化分治）与小顶堆两种主流方案，并提供排序基线对比，附完整Java代码与边界处理，适合面试刷题与算法进阶读者。