【Top K 优先队列 建堆】 215 数组中的第k个最大的元素

题目

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

思路

1. 建立大根堆，弹出k-1个元素，那么堆顶就是第k大的元素。
   或者建立小跟堆，弹出len-k个元素，堆顶就是第k大的元素
2. 快排寻找
3. 手动建立小根堆
4. 手动建立大根堆

代码

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> queue = new PriorityQueue<>(nums.length,(a, b) -> b - a);
    for(int i = 0;i<nums.length;i++){
        queue.add(nums[i]);
    }
    for(int i=0;i<k-1;i++){
        queue.poll();
    }
    return queue.peek();


}

public class Finder {
    public int findKth(int[] a, int n, int K) {
        // write code here
        return findK(a, 0, n-1, K);
    }
 
        public static int partition(int[] arr, int left, int right) {
        int pivot = arr[left];
 
        while (left < right) {
            while (left < right && arr[right] <= pivot) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] >= pivot) {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = pivot;
        return left;
    }
 
    public static int findK(int[] arr, int left, int right, int k) {
        if (left <= right) {
            int pivot = partition(arr, left, right);
 
            if (pivot == k - 1) {
                return arr[pivot];
            } else if (pivot < k - 1) {
                return findK(arr, pivot + 1, right, k);
            } else {
                return findK(arr, left, pivot - 1, k);
            }
        }
        return -1;
    }
}

3. 手动建立小根堆

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 构建小根堆，堆顶最小，堆大小就是前k个大的元素
        // 先构建前k / 2 - 1个元素，后面再逐个添加元素进去比较
        buildMinHeap(nums, k);
        for(int i = k; i < nums.length; i++) {
            if(nums[i] < nums[0]) continue;
            swap(nums, 0, i);
            adjMinHeap(nums, 0, k);
        }
        return nums[0];
    }

    public void buildMinHeap(int[] nums, int k) {
        for(int i = k / 2 - 1; i >= 0; i--) {
            adjMinHeap(nums, i, k);
        }
    }

    public void adjMinHeap(int[]nums, int root, int heapSize) {
        int left = root * 2 + 1;
        int right = root * 2 + 2;
        int minnum = root;
        // 找到root left和right中最小的节点，让其成为根节点
        if(left < heapSize && nums[left] < nums[minnum]) minnum = left;
        if(right < heapSize && nums[right] < nums[minnum]) minnum = right;
        if(minnum != root) {
            swap(nums, minnum, root);
            adjMinHeap(nums, minnum, heapSize);
        }
    }

     public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

4. 手动建立大根堆

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int heapSize = nums.length;
        buildMaxHeap(nums, heapSize);
        for (int i = nums.length - 1; i >= nums.length - k + 1; --i) {
            swap(nums, 0, i);
            --heapSize;
            maxHeapify(nums, 0, heapSize);
        }
        return nums[0];
    }

    public void buildMaxHeap(int[] a, int heapSize) {
        for (int i = heapSize / 2; i >= 0; --i) {
            maxHeapify(a, i, heapSize);
        } 
    }

    public void maxHeapify(int[] a, int i, int heapSize) {
        int l = i * 2 + 1, r = i * 2 + 2, largest = i;
        if (l < heapSize && a[l] > a[largest]) {
            largest = l;
        } 
        if (r < heapSize && a[r] > a[largest]) {
            largest = r;
        }
        if (largest != i) {
            swap(a, i, largest);
            maxHeapify(a, largest, heapSize);
        }
    }

    public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}