算法通关村第10关——数组中第k大的数字（白银）

leetcode 215. 数组中的第K个最大元素

注意快排的最后这两个递归参数：

quickSort(arr, start, right);        
quickSort(arr, left, end);

因为在上一次循环结束后，right指针指向的是小于等于基准值的最右边元素，所以需要对左半部分进行递归排序，即quickSort(arr, start, right);。

而left指针指向的是大于等于基准值的最左边元素，所以需要对右半部分进行递归排序，即quickSort(arr, left, end);。

这道题的题目就多了个k，其实就是快速排序后取倒是第k个

class Solution {
    public int findKthLargest(int[] nums, int k) {
        quickSort(nums, 0, nums.length - 1);
        return nums[nums.length - k];
    }
    private static void quickSort(int[] arr, int start, int end) {
        if(start >= end){
            return;
        }
        int left = start, right = end;
        int pivot = arr[start + ((end - start)>>1)];
        while(left <= right){
            while(left <= right && arr[left] < pivot){
                left++;
            }
            while(left <= right && arr[right] > pivot){
                right--;
            }
            if(left <= right){
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }
        quickSort(arr, start, right);
        quickSort(arr, left, end);

    }
}

同理，还可以用堆来实现：

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 创建一个最小堆
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
        
        // 将数组中的前k个元素加入最小堆
        for (int i = 0; i < k; i++) {
            minHeap.offer(nums[i]);
        }
        
        // 遍历数组剩余元素，如果比堆顶元素大则替换堆顶元素，并重新调整堆
        for (int i = k; i < nums.length; i++) {
            if (nums[i] > minHeap.peek()) {
                minHeap.poll();
                minHeap.offer(nums[i]);
            }
        }
        
        // 返回最小堆的堆顶元素，即第k个最大元素
        return minHeap.peek();
    }
}