[路飞]_程序员必刷力扣题: 215. 数组中的第K个最大元素

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

给定整数数组 nums 和整数 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

提示：

• 1 <= k <= nums.length <= 104
• -104 <= nums[i] <= 104

大顶堆排序

思路 这里我们使用一个大顶堆来存储所有元素

• 初始化堆，使数据流中最大值在第一位
• 循环k次遍历，每次取出堆中的最大值

第k次就是我们需要的数组中的第k个最大元素了

class Heap {
    constructor(nums, compare) {
        this.arr = nums
        this.compare = compare
        for (var i = (this.arr.length >> 1) - 1; i >= 0; i--) {
            this.heapify(i)
        }
        
    }
    heapify(index) {
        var data = this.arr
        var target = index
        var left = index * 2 + 1
        var right = index * 2 + 2
        if (left < data.length && this.compare(data[left], data[target])) {
            target = left
        }
        if (right < data.length && this.compare(data[right], data[target])) {
            target = right
        }
        if (target != index) {
            this.swap(target, index)
            this.heapify(target)
        }
    }
    swap(l, r) {
        let data = this.arr;
        [data[l], data[r]] = [data[r], data[l]];
    }
    push(val) {
        var data = this.arr
        this.arr.push(val)
        this.buildMaxHeap()
        let index = this.arr.length - 1
        let father = ((index + 1) >> 1) - 1
        while (father >= 0) {
            var indexVal = data[index]
            var fatherVal = data[father]
            if (indexVal > father) {
                this.swap(index, target)
                index = father
                father = ((index + 1) >> 1) - 1
            } else {
                break
            }
        }
    }
    pop() {
        this.swap(0, this.arr.length - 1)
        var res = this.arr.pop()
        this.heapify(0)
        return res
    }

}
var findKthLargest = function (nums, k) {
    var dp = new Heap(nums, (target, root) => target > root)
    var i = 0
    var res;
    while (i < k) {
        res = dp.pop()
        i++
    }
    return res

};