typescript 实现一个大根堆

大根堆是一个用数组实现的二叉树结构，根节点一定比子节点大，稳定弹出根节点来实现从大到小排序

class MaxHeap {
    private heapSize: number = 0;
    constructor(public heap: number[]) {
        this.buildHeap(this.heap, this.heapSize)
    }


    //初始化堆
    public buildHeap(heap: number[], heapSize: number) {
        //倒序去遍历节点执行下沉操作
        if (heap.length === 0) return;
        heapSize = heap.length;
        for (let i = heapSize - 1; i >= 0; i--) {
            this.heapify(i, heapSize, heap)
        }
    }
    //实现堆的添加操作
    public push(val: number) {
        this.heap.push(val);
        this.heapSize++;
        //对堆进行上移操作
        this.heapInsert(this.heapSize - 1, this.heap)
    }

    //实现堆的弹出堆顶元素操作
    public pop(): number | undefined {
        //取出堆顶元素后，让堆尾元素来到堆首然后下沉
        if (this.heapSize === 0) return;
        let res = this.heap[0];
        this.heap[0] = this.heap[this.heapSize - 1];
        this.heapSize--;
        this.heapify(0, this.heapSize, this.heap);
        return res;
    }

    //实现堆的上移操作
    private heapInsert(index: number, heap: number[]): void {
        while (index > 0) {
            if (heap[index] > heap[(index - 1) >> 1]) {
                [heap[index], heap[(index - 1) >> 1]] = [heap[(index - 1) >> 1], heap[index]]
                index = (index - 1) >> 1;
            } else {
                break;
            }
        }
    }

    //实现堆下沉操作
    private heapify(index: number, heapSize: number, heap: number[]): void {
        let left = index << 1 | 1;
        while (left < heapSize) {
            let maxIndex = left + 1 < heapSize && heap[left + 1] > heap[left] ? left + 1 : left;
            if (heap[index] < heap[maxIndex]) {
                [heap[index], heap[maxIndex]] = [heap[maxIndex], heap[index]]
                index = maxIndex;
                left = index << 1 | 1;
            } else {
                break;
            }
            if (left > heapSize) break;
        }
    }
}