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