最小堆算法初探：快速搞懂核心应用及实现

后端

2022-12-30 02:46:54

了解最小堆：一种维护数据的便捷数据结构

在数据结构的世界里，最小堆脱颖而出，以其非凡的能力在各种应用程序中管理和组织数据。在这篇全面指南中，我们将深入探索最小堆的内部运作原理、实现细节及其广泛的应用。

最小堆：一个分层数据结构

想象一下一座树，从根部延伸出无数的分支，形成一个金字塔状的结构。这就是最小堆的本质。它是一种特殊的二叉树，每个节点都有一个值，并遵循以下规则：

每个节点都比其子节点小或等于其子节点。
根节点是堆中最小的值。

最小堆的实现

我们可以使用数组或链表来实现最小堆。数组提供了一个简洁且内存高效的方式，而链表在插入或删除节点时提供了更大的灵活性。

数组实现：

class MinHeap:
    def __init__(self):
        self.heap = []

    # 插入一个值
    def insert(self, value):
        self.heap.append(value)
        self.heapify_up()

    # 维护堆的性质
    def heapify_up(self):
        i = len(self.heap) - 1
        while i > 0:
            parent = (i - 1) // 2
            if self.heap[i] < self.heap[parent]:
                self.heap[i], self.heap[parent] = self.heap[parent], self.heap[i]
            i = parent

    # 弹出最小值
    def pop(self):
        if len(self.heap) == 0:
            return None
        value = self.heap[0]
        self.heap[0] = self.heap.pop()
        self.heapify_down()
        return value

    # 维护堆的性质
    def heapify_down(self):
        i = 0
        while True:
            left = 2 * i + 1
            right = 2 * i + 2
            smallest = i
            if left < len(self.heap) and self.heap[left] < self.heap[smallest]:
                smallest = left
            if right < len(self.heap) and self.heap[right] < self.heap[smallest]:
                smallest = right
            if smallest != i:
                self.heap[i], self.heap[smallest] = self.heap[smallest], self.heap[i]
                i = smallest
            else:
                break

链表实现：

class MinHeapNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

class MinHeap:
    def __init__(self):
        self.root = None

    # 插入一个值
    def insert(self, value):
        new_node = MinHeapNode(value)
        if self.root is None:
            self.root = new_node
        else:
            self._insert(new_node, self.root)

    # 辅助插入方法
    def _insert(self, new_node, current_node):
        if new_node.value < current_node.value:
            if current_node.left is None:
                current_node.left = new_node
            else:
                self._insert(new_node, current_node.left)
        else:
            if current_node.right is None:
                current_node.right = new_node
            else:
                self._insert(new_node, current_node.right)

    # 弹出最小值
    def pop(self):
        if self.root is None:
            return None
        value = self.root.value
        self.root = self._pop(self.root)
        return value

    # 辅助弹出方法
    def _pop(self, current_node):
        if current_node.left is None and current_node.right is None:
            return None
        elif current_node.left is None:
            return current_node.right
        elif current_node.right is None:
            return current_node.left
        else:
            left_subtree = self._pop(current_node.left)
            current_node.left = left_subtree
            return current_node