本文正在参加「Java主题月 - Java 刷题打卡」，详情查看 活动链接

一、题目描述

二、解题思路

1.排序

我们一般第一想法就是把数组排好序，假设是升序的化K大元素就是数组下标k-1。
那：

• 算法的复杂度=排序算法的复杂度。
  可选排序算法有快速排序、堆排序等等。

时间复杂度分析

• 快速排序：O(nlogn)
• 堆排序：O(nlogn)

空间复杂度分析

• 快速排序：O(1)
• 堆排序（原数组上操作）：O(1)

2.快速排序优化

我们的目标是找到数组中的第K大元素，其实我们对元素是否有序并不关心。因此对数组进行排序其实其中的很多比较不是我们期望的。那如何优化呢？
回顾一下快速排序，这是一个典型的分治算法。我们对数组 a[l⋯r] 做快速排序的过程是（参考《算法导论》）：

• 分解： 将数组 a[l⋯r] 「划分」成两个子数组 a[l⋯q−1]、a[q+1⋯r]，使得 a[l⋯q−1] 中的每个元素小于等于 a[q]a[q]，且 a[q]a[q] 小于等于 a[q+1⋯r] 中的每个元素。其中，计算下标 qq 也是「划分」过程的一部分。
• 解决： 通过递归调用快速排序，对子数组 a[l⋯q−1] 和 a[q+1⋯r] 进行排序。
• 合并： 因为子数组都是原址排序的，所以不需要进行合并操作，a[l⋯r] 已经有序。
• 上文中提到的 「划分」 过程是：从子数组 a[l⋯r] 中选择任意一个元素 x 作为主元，调整子数组的元素使得左边的元素都小于等于它，右边的元素都大于等于它， x 的最终位置就是 q。 发现了什么没有，分治算法意味着我们可以不用处理不包含答案的那部分。

所以只要某次划分的 q 为倒数第 k 个下标的时候，我们就已经找到了答案。

时间复杂度分析

• O(n)
  证明过程可以参考「《算法导论》9.2：期望为线性的选择算法」。

空间复杂度分析

• O(1)

三、代码实现

class Solution {
    Random random = new Random();

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

    public int quickSelect(int[] a, int l, int r, int index) {
        int q = randomPartition(a, l, r);
        if (q == index) {
            return a[q];
        } else {
            return q < index ? quickSelect(a, q + 1, r, index) : quickSelect(a, l, q - 1, index);
        }
    }

    public int randomPartition(int[] a, int l, int r) {
        //增加随机性
        int i = random.nextInt(r - l + 1) + l;
        swap(a, i, r);
        return partition(a, l, r);
    }

    public int partition(int[] a, int l, int r) {
        int x = a[r], i = l - 1;
        for (int j = l; j < r; ++j) {
            if (a[j] <= x) {
                swap(a, ++i, j);
            }
        }
        swap(a, i + 1, r);
        return i + 1;
    }

    public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}