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 ≤ 数组的长度。

二、求解

解法一：快速选择算法

跟快速排序是一个人发明的，思想和快速排序一样，平均时间复杂度为 $O(n)$。
第一次是 $O(n)$，第二次是 $O(n/2)$，第三次是 $O(n/4)$ … 第 $n$ 次是 $O(n/n)$，总时间复杂度就是 $O(n+n/2+n/4....+1)=O(2n-1)=O(n)$。

class Solution {
    private int[] nums;
    private int k;
    
    public int findKthLargest(int[] nums, int k) {
        this.nums = nums;
        this.k = k;
        return quickSelect(0, nums.length-1);
    }
    
    private int quickSelect(int start, int end){
        int random = start + (int)(Math.random()*(end-start+1));
        int pivot = nums[random];
        nums[random] = nums[start];
        int i = start, j = end;
        while(i < j){
            while(i < j && nums[j] <= pivot) --j;
            nums[i] = nums[j];
            while(i < j && nums[i] >= pivot) ++i;
            nums[j] = nums[i];
        }
        if(i == k-1) return pivot;
        nums[i] = pivot;
        if(i > k-1) return quickSelect(start, i-1);
        else return quickSelect(i+1, end);
    }
}

从测试用例的运行结果来看，随机选择枢轴确实要比固定选择快得多。

随机数的生成记住两种：

1. new Random().nextInt(n)，生成范围在 [0, n) 的一个整数。
2. Math.random()，返回值为 double，范围在 [0, 1)。

解法二：小根堆

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 小根堆，采样自下而上的建堆方式
        for(int i = k/2-1; i >= 0; --i){
            siftDown(nums, i, k);
        }
        for(int i = k; i < nums.length; ++i){
            if(nums[i] <= nums[0]) continue;
            nums[0] = nums[i];
            siftDown(nums, 0, k);
        }
        return nums[0];
    }

    private void siftDown(int[] nums, int i, int len){
        int e = nums[i];
        int half = len >> 1;
        while(i < half){
            // 先令 child 指向 i 的左孩子
            int child = (i << 1) + 1;
            // 如果 i 的右孩子更小，令 child 指向右孩子
            if(child+1 < len && nums[child+1] < nums[child]) ++child;
            // 如果两个孩子都大于 e，直接跳出
            if(e <= nums[child]) break;
            nums[i] = nums[child];
            i = child;
        }
        nums[i] = e;
    }
}

时间复杂度分析，自下而上建了一个含有 $k$ 个元素的堆，时间复杂度为 $O(k)$，后面对这个堆最多调整 $n-k$ 次，时间复杂度为 $O((n-k)\log k)$，所以整体的时间复杂度为 $O(n\log k)$。

知识点补充：1. 自下而上建堆

适用于所有堆元素已知的情况，一般也是这样。
不断地向下筛选（siftDown）。

public void buildHeap(int[] nums){
	for(int i = nums.length/2-1; i >= 0; --i){
		siftDown(nums, i, nums.length);
	}
}

/**
 * @param nums 层次遍历表示的完全二叉树的堆数组
 * @param i 要向下调整的结点位置
 * @param len 堆大小
 */
private void siftDown(int[] nums, int i, int len){
    int e = nums[i];
    int half = len >> 1;
    while(i < half){
        // 先令 child 指向 i 的左孩子
        int child = (i << 1) + 1;
        // 如果 i 的右孩子更小，令 child 指向右孩子
        if(child+1 < len && nums[child+1] < nums[child]) ++child;
        // 如果两个孩子都大于 e，直接跳出
        if(e <= nums[child]) break;
        nums[i] = nums[child];
        i = child;
    }
    nums[i] = e;
}

自下而上建堆的时间复杂度：参见严蔚敏教材，结论为 $O(n)$。

2. 自上而下建堆（插入建堆）

适用于动态添加堆元素的情况。

public void buildHeap(int[] nums){
	for(int i = 0; i < nums.length; ++i){
		siftUp(nums, i);
	}
}

/**
 * @param nums 堆数组，[0, i) 部分已经堆化
 * @param i 待插入元素的位置
 */
public void siftUp(int[] nums, int i){
	int e = nums[i];
	while(i > 0){
		int parent = (i-1) >> 1;
		if(nums[parent] <= e) break;
		nums[i] = nums[parent];
		i = parent;
	}
	nums[i] = e;
}

插入建堆的时间复杂度为 $O(n\log n)$。