用 TypeScript 实现高效二叉堆：深入浅出解读

2024-01-10 15:14:06

引言

二叉堆是一种完全二叉树，其中每个节点的值都大于或等于（最小堆）或小于或等于（最大堆）其子节点的值。这种独特的结构使二叉堆能够以 O(log n) 的时间复杂度快速查找最大值或最小值，非常适用于优先队列和堆排序算法。

TypeScript 实现

以下是使用 TypeScript 实现的二叉堆类：

class BinaryHeap {
    private heap: number[];
    private minHeap: boolean;

    constructor(minHeap = true) {
        this.heap = [];
        this.minHeap = minHeap;
    }

    insert(value: number) {
        this.heap.push(value);
        this.bubbleUp(this.heap.length - 1);
    }

    extract() {
        if (this.heap.length === 0) {
            return null;
        }

        let root = this.heap[0];
        this.heap[0] = this.heap.pop()!;
        this.bubbleDown(0);

        return root;
    }

    private bubbleUp(index: number) {
        while (index > 0) {
            let parentIndex = Math.floor((index - 1) / 2);
            if ((this.minHeap && this.heap[index] >= this.heap[parentIndex]) ||
                (!this.minHeap && this.heap[index] <= this.heap[parentIndex])) {
                break;
            }

            this.swap(index, parentIndex);
            index = parentIndex;
        }
    }

    private bubbleDown(index: number) {
        while (index < this.heap.length) {
            let leftChildIndex = 2 * index + 1;
            let rightChildIndex = 2 * index + 2;
            let swapIndex = index;

            if (leftChildIndex < this.heap.length) {
                if ((this.minHeap && this.heap[leftChildIndex] < this.heap[swapIndex]) ||
                    (!this.minHeap && this.heap[leftChildIndex] > this.heap[swapIndex])) {
                    swapIndex = leftChildIndex;
                }
            }

            if (rightChildIndex < this.heap.length) {
                if ((this.minHeap && this.heap[rightChildIndex] < this.heap[swapIndex]) ||
                    (!this.minHeap && this.heap[rightChildIndex] > this.heap[swapIndex])) {
                    swapIndex = rightChildIndex;
                }
            }

            if (swapIndex === index) {
                break;
            }

            this.swap(index, swapIndex);
            index = swapIndex;
        }
    }

    private swap(index1: number, index2: number) {
        let temp = this.heap[index1];
        this.heap[index1] = this.heap[index2];
        this.heap[index2] = temp;
    }
}

用法

以下代码展示了如何使用该二叉堆类：

const heap = new BinaryHeap();
heap.insert(5);
heap.insert(3);
heap.insert(10);
heap.insert(1);

while (heap.heap.length > 0) {
    console.log(heap.extract());
}