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

题目

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明:
你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

解题思路

解法一：小根堆

由于Java中优先队列默认是小根堆，所以可以遍历整个数组，在 for 循环里面判断小根堆的 size() 是否大于 k 个数，是的话就 poll() 出去。整个 for 循环结束之后堆中剩下来的就是整个数组最大的 k 个数，堆顶即第 k 大的数。

复杂度分析：
时间复杂度：O(nlogk)，其中 n 是数组的长度。由于小根堆实时维护前 k 大值，所以插入删除都是 O(logk) 的时间复杂度，最坏情况下数组里 n 个数都会插入，所以一共需要 O(nlogk) 的时间复杂度。
空间复杂度：O(k)，因为小根堆里最多 k 个数。

解法二：快速选择

我们对数组 a[l⋯r] 做快速排序的过程是：
1） 将数组 a[l⋯r] 「划分」成两个子数组 a[l⋯q−1]、a[q+1⋯r]，使得 a[l⋯q−1] 中的每个元素小于等于 a[q]，且 a[q] 小于等于 a[q+1⋯r] 中的每个元素。其中，计算下标q 也是「划分」过程的一部分。
2） 通过递归调用快速排序，对子数组 a[l⋯q−1] 和 a[q+1⋯r] 进行排序。

上文中提到的 「划分」 过程是：从子数组a[l⋯r] 中选择任意一个元素 x 作为主元，调整子数组的元素使得左边的元素都小于等于它，右边的元素都大于等于它， x 的最终位置就是 q。由此可以发现每次经过「划分」操作后，我们一定可以确定一个元素的最终位置，即 x 的最终位置为 q，并且保证 a[l⋯q−1] 中的每个元素小于等于 a[q]，且 a[q] 小于等于 a[q+1⋯r] 中的每个元素。所以只要某次划分的 q 为倒数第 k 个下标的时候，我们就已经找到了答案，至于 a[l⋯q−1] 和 a[q+1⋯r] 是否是有序的，我们不关心。

因此我们可以改进快速排序算法来解决这个问题：在分解的过程当中，我们会对子数组进行划分，如果划分得到的 q 正好就是我们需要的下标，就直接返回 a[q]；否则，如果 q 比目标下标小，就递归右子区间，否则递归左子区间。

复杂度分析：
时间复杂度：O(n)。
空间复杂度：O(logn)。

注：快速排序的性能和「划分」出的子数组的长度密切相关。如果每次规模为 n的问题我们都划分成 1 和 n - 1，每次递归的时候又向 n−1 的集合中递归，这种情况是最坏的，时间代价是 O(n ^ 2)，例如顺序数组或倒序数组的情况。我们可以引入随机化来加速这个过程，可以在循环一开始的时候，交换第 1 个元素与它后面的任意 1 个元素的位置，它的时间代价的期望是 O(n)。

代码

解法一：小根堆

class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        // 含比较器的写法，如果是大根堆，则是 (a,b) -> b-a
        //PriorityQueue<Integer> heap = new PriorityQueue<>((a,b) -> a-b);
        for(int num : nums){
            heap.add(num);
            if(heap.size()>k){
                heap.poll();
            }
        }
        return heap.peek();
    }
}

解法二：快速选择

import java.util.Random;
class Solution {
    public int findKthLargest(int[] nums, int k) {
        int len = nums.length;
        int low = 0;
        int high = len-1;
        int target = len-k;
        while(true){
            int index = partition(nums, low, high);
            if(index == target){
                return nums[index];
            }else if(index < target){
                low = index+1;
            }else{
                high = index-1;
            }
        }
    }

    private int partition(int[] nums, int start, int end){
        // 随机化
        if(start<end){
            // 生成 [0, end-start]的随机int值
            Random random = new Random();
            int randomIndex = random.nextInt(end-start+1);
            swap(nums, start, start+randomIndex);
        }
        // 基准数据
        int pivot = nums[start];
        while(start < end){
            // 当队尾的元素大于等于pivot时，向前挪动end指针
            while(start<end && nums[end]>=pivot){
                end--;
            }
            // 如果队尾元素小于pivot了，需要将其赋值给start
            // nums[start] = nums[end];
            // 如果队尾元素小于pivot了，将这个比pivot小的元素交换到前半部分
            swap(nums, start, end);
            // 当队首元素小于等于pivot时，向前挪动start指针
            while(start<end && nums[start]<=pivot){
                start++;
            }
            // 当队首元素大于pivot时，需要将其赋值给end
            // nums[end] = nums[start];
            // 如果队首元素大于pivot了，将这个比pivot大的元素交换到后半部分
            swap(nums, start, end);
        }
        // 如果上面用的是交换的话，此处就不用再赋值了
        // nums[start] = pivot;
        // 返回基准元素所在的位置
        return start;
    }

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