LeetCode：215. 数组中的第K个最大元素

简介

题目链接：https://leetcode.cn/problems/kth-largest-element-in-an-array/description/

解决方式：数组 + 分治法（快速排序）、优先队列

这是作者学习众多大神的思路进行解题的步骤，很推荐大家解题的时候去看看题解里面大佬们的思路、想法！

推荐看 Krahets 大佬的讲解。

分治法

解题思路：此题我们只需要找到数组中第 k 个大元素就好，所以才去分治的方式将大数组分成三个小数组（大、等、小）。对比 k 元素所处位置，只递归处理目标所处的数组，得到我们需要的结果，而不对整个数组进行排序。此外，目标元素在 big、small 数组中，我们就一直递归，知道最终结果所处 equals 中，然后返回数据。即，一直缩小范围，直到找到结果。

java 复制代码

class Solution {
    public int quickSelect(List<Integer> nums, int k) {
        // 随机选择哨兵
        Random rand = new Random();
        int pivot = nums.get(rand.nextInt(nums.size()));
        // 分治划分，大、等、小三个数组
        ArrayList<Integer> big = new ArrayList();
        ArrayList<Integer> equals = new ArrayList();
        ArrayList<Integer> small = new ArrayList();
        // 分治
        for(int num : nums){
            if(num > pivot){
                big.add(num);
            }else if(num < pivot){
                small.add(num);
            }else{
                equals.add(num);
            }
        }
        // 递归
        // 若 k 在 big、small 中则一直迭代，直到目标在 equals 中
        if(k <= big.size()){
            // 目标在 big 中，迭代 big
            return quickSelect(big, k);
        }else if(nums.size() - small.size() < k){
            // 目标在 small 中，迭代 small
            // k 需要进行转换，变成 small 中的第几个元素
            return quickSelect(small, k - nums.size() + small.size());
        }else{
            // 目标在 equals 中，找到目标
            return pivot;
        }
    }

    public int findKthLargest(int[] nums, int k){
        List<Integer> numList = new ArrayList<>();
        for (int num : nums) {
            numList.add(num);
        }
        return quickSelect(numList, k);
    }
}

内置算法

解题思路：需要找到第 k 个大元素，那么我们可以先对数组进行排序，然后再返回从右往左数的第 k 个元素，也就是第 k 个大元素了。排序算法可以自己实现，也可以使用内置算法。此处使用的是内置算法。

java 复制代码

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 排序，使用高级语言内置排序算法
        int n = nums.length;
        Arrays.sort(nums);
        // 返回
        return nums[n - k];
    }
}

优先队列（小顶堆）

解题思路：使用堆这个数据结构，其可以在运行时实时维护内部的顺序，无需考虑排序问题。堆中维护 k 个元素，这 k 个元素表示数组中的最大 k 个元素，这样堆顶（小顶堆）元素自然就是第 k 个最大元素了。

java 复制代码

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 优先队列
        PriorityQueue<Integer> heap = new PriorityQueue<>(k, Comparator.comparingInt(a -> a));
        // 先将 k 个元素加入堆中
        for(int i = 0; i < k; i++){
            heap.offer(nums[i]);
        }
        // 遍历数组后续元素
        for(int i = k; i < nums.length; i++){
            // 如果元素比堆顶大，说明该元素是 k 个大元素之一，放入堆中
            if(nums[i] > heap.peek()){
                // 堆顶元素出堆（堆中 k 个元素最小的）
                heap.poll();
                // 入堆
                heap.offer(nums[i]);
            }
        }
        // 返回结果
        return heap.peek();
    }
}

另一种处理方法：

java 复制代码

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 优先队列
        PriorityQueue<Integer> heap = new PriorityQueue();
        // 将数组元素直接放进堆中
        for(int num : nums){
            heap.offer(num);
            // 维护 k 个元素，队列中的元素个数超出则堆顶元素出堆
            if(heap.size() > k){
                heap.poll();
            }
        }
        // 返回结果
        return heap.peek();
    }
}

这种处理方法时间效率不如上面的方式，因为每次都要判断。