用Python征服红黑树：步入数据结构的奇幻旅程

2023-04-03 01:09:01

征服红黑树：平衡二叉树的奇妙旅程

踏入数据结构的奇幻世界，红黑树以其卓越的效率脱颖而出，让人不禁心生敬畏。这种平衡二叉查找树巧妙地将二叉查找树的严谨性与红色和黑色节点的微妙平衡相结合，为数据存储和检索带来了前所未有的速度与优雅。

二叉树：坚实的基础

二叉树宛若树木的抽象化，每个节点都象征着一棵子树。它可以向左和向右延伸，从而形成分支结构。二叉查找树（BST）在二叉树的基础上更进一步，它要求每个节点的值都大于其左子节点的值，而小于其右子节点的值。这种精妙的组织方式使得在 BST 中查找数据变得极其高效。

红黑树：平衡之美

然而，BST 存在一个潜在的缺陷：它可能会退化成一条链，从而严重影响其效率。为了解决这个问题，红黑树闪亮登场。红黑树通过将 BST 的每个节点着色为红色或黑色，并引入一系列平衡规则来实现平衡。

红黑树的平衡规则：

每个节点都是红色或黑色。
根节点始终是黑色。
没有两个连续的红色节点。
从任何节点到其后代叶节点的路径上的黑色节点数是相同的。

Python 中的红黑树实现

为了充分领略红黑树的威力，让我们亲自动手用 Python 来实现一个。

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.color = "red"
        self.left = None
        self.right = None

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

    def insert(self, key, value):
        new_node = Node(key, value)
        self._insert(new_node)

    def _insert(self, new_node):
        if self.root is None:
            self.root = new_node
            return

        parent = None
        current = self.root
        while current is not None:
            parent = current
            if new_node.key < current.key:
                current = current.left
            else:
                current = current.right

        if new_node.key < parent.key:
            parent.left = new_node
        else:
            parent.right = new_node

        self._fix_insert(new_node)

    def _fix_insert(self, new_node):
        # Case 1: new_node is the root node
        if new_node is self.root:
            new_node.color = "black"
            return

        # Case 2: new_node's parent is black
        if new_node.parent.color == "black":
            return

        # Case 3: new_node's parent is red and new_node's uncle is red
        uncle = self._get_uncle(new_node)
        if uncle and uncle.color == "red":
            new_node.parent.color = "black"
            uncle.color = "black"
            new_node.parent.parent.color = "red"
            self._fix_insert(new_node.parent.parent)
            return

        # Case 4: new_node's parent is red and new_node's uncle is black
        if new_node.parent.color == "red" and (not uncle or uncle.color == "black"):
            if new_node == new_node.parent.right and new_node.parent == new_node.parent.parent.left:
                self._left_rotate(new_node.parent)
                new_node = new_node.left
            elif new_node == new_node.parent.left and new_node.parent == new_node.parent.parent.right:
                self._right_rotate(new_node.parent)
                new_node = new_node.right

            new_node.parent.color = "black"
            new_node.parent.parent.color = "red"
            if new_node == new_node.parent.left:
                self._right_rotate(new_node.parent.parent)
            else:
                self._left_rotate(new_node.parent.parent)

    def _get_uncle(self, node):
        if node.parent is None or node.parent.parent is None:
            return None

        if node.parent == node.parent.parent.left:
            return node.parent.parent.right
        else:
            return node.parent.parent.left

    def _left_rotate(self, node):
        right_child = node.right
        node.right = right_child.left
        if right_child.left is not None:
            right_child.left.parent = node

        right_child.parent = node.parent
        if node.parent is None:
            self.root = right_child
        elif node == node.parent.left:
            node.parent.left = right_child
        else:
            node.parent.right = right_child

        right_child.left = node
        node.parent = right_child

    def _right_rotate(self, node):
        left_child = node.left
        node.left = left_child.right
        if left_child.right is not None:
            left_child.right.parent = node

        left_child.parent = node.parent
        if node.parent is None:
            self.root = left_child
        elif node == node.parent.right:
            node.parent.right = left_child
        else:
            node.parent.left = left_child

        left_child.right = node
        node.parent = left_child