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