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);
    }
}

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

知识点补充：java 生成随机数

记住两种：

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

Math.random() 源码：

Math.random() 的设计采用了单例模式（不是严格的单例模式，这里指从 Math.random() 这个入口进，只会实例化一个 Random 对象，并不是 Random 只能实例化一个对象）。
random() 是 java.lang.Math 中的一个静态函数：

public static double random() {
    return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}

Math$RandomNumberGeneratorHolder.class

private static final class RandomNumberGeneratorHolder {
    static final Random randomNumberGenerator = new Random();
}

很明显是一个静态内部类写法的单例模式。
最后用的还是 java.util.Random 这个类的对象。

public double nextDouble() {
    return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT;
}

protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask;
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

最终的 next 函数使用了 CAS 乐观锁机制。

new Random().nextInt(n) 源码：

public int nextInt(int bound) {
    if (bound <= 0)
        throw new IllegalArgumentException(BadBound);

    int r = next(31);
    int m = bound - 1;
    if ((bound & m) == 0)  // i.e., bound is a power of 2
        r = (int)((bound * (long)r) >> 31);
    else {
        for (int u = r;
             u - (r = u % bound) + m < 0;
             u = next(31))
            ;
    }
    return r;
}

protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask;
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

两种方式最后调用的都是 next 方法。

解法二：小根堆

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)$。

解法三：大根堆

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

    private void siftUp(int[] nums, int i){
        int e = nums[i];
        while(i > 0){
            int parent = (i-1) >> 1;
            if(e <= nums[parent]) break;
            nums[i] = nums[parent];
            i = parent;
        }
        nums[i] = e;
    }

    private void siftDown(int[] nums, int i, int len){
        int e = nums[i];
        int half = len >> 1;
        while(i < half){
            int child = (i << 1) + 1;
            if(child+1 < len && nums[child+1] > nums[child]) ++child;
            if(e >= nums[child]) break;
            nums[i] = nums[child];
            i = child;
        }
        nums[i] = e;
    }
}

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

适用于所有堆元素已知的情况，一般也是这样。
会用到向下调整的操作（siftDown）。
向下调整函数常见的函数名：heapAdjust，adjustHeap，heapify，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;
}

为什么从 nums.length/2-1 开始，它为什么是第一个非叶结点的下标？
一般数组下标为 0 的位置也是堆的一部分，则下标为 i 的左右子结点分别为 2*i+1 和 2*i+2（想不起来时，想三个结点的情况 [0, 1, 2]（层次遍历表示））。
而严蔚敏版数据结构书上，堆的起始位置是 1，所以下标为 i 的左右子结点分别为 2*i 和 2*i+1。

这里的 nums.length 是堆大小，所以最后一个叶结点的下标为 nums.length-1。
找第一个非叶结点就是找最后一个叶结点的父结点。
我们用 $k$ 表示堆大小，则最后一个叶结点的下标为 $k-1$。
令 $2*i+1=k-1$，此时叶结点为左子结点，所以 $i=k/2-1$。
令 $2*i+2=k-1$，此时叶结点为右子结点，所以 $k$ 一定为奇数，首先有 $\lfloor k/2\rfloor =(k-1)/2$，所以 $i=(k-3)/2=(k-1)/2-1=\lfloor k/2\rfloor-1$。
由于 java 的整数除法是自动向下取整的，所以第一个非叶结点下标为 nums.length/2-1。

自下而上建堆的时间复杂度：参见严蔚敏教材，结论为 $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)$。