深入理解红黑树：带您手动实现数据结构

后端

2024-01-05 00:32:11

红黑树：平衡与高效的数据结构

数据结构在计算机科学中至关重要，它们为组织和存储数据提供了一个系统和有效的方法。红黑树 是一种平衡树，将二叉查找树的优点与平衡树的稳定性相结合，从而实现高效的搜索、插入和删除操作。

了解红黑树：关键概念

在深入研究红黑树之前，让我们了解其基本概念：

结点颜色： 红黑树中的结点具有红色或黑色的颜色。红色结点表示不平衡的子树，而黑色结点表示平衡的子树。
左倾旋转和右倾旋转： 通过旋转操作来调整树的结构，保持平衡。左倾旋转将子树的右孩子旋转到父结点的左边，而右倾旋转将子树的左孩子旋转到父结点的右边。
插入和删除操作： 插入和删除操作类似于二叉查找树，但需要在插入和删除后重新平衡树。

手动实现红黑树

为了更深入地理解红黑树，让我们逐步实现一个简单的红黑树数据结构：

class Node:
    def __init__(self, key, value, color="black"):
        self.key = key
        self.value = value
        self.color = color
        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)
        self._rebalance(new_node)

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

        parent = self._find_parent(new_node.key)
        if new_node.key < parent.key:
            parent.left = new_node
        else:
            parent.right = new_node

    def _find_parent(self, key):
        parent = None
        current = self.root
        while current is not None:
            if key < current.key:
                parent = current
                current = current.left
            elif key > current.key:
                parent = current
                current = current.right
            else:
                return None  # Key already exists in the tree
        return parent

    def _rebalance(self, new_node):
        while new_node != self.root and new_node.parent.color == "red":
            if new_node.parent == new_node.parent.parent.left:
                uncle = new_node.parent.parent.right

                if uncle.color == "red":
                    new_node.parent.color = "black"
                    uncle.color = "black"
                    new_node.parent.parent.color = "red"
                    new_node = new_node.parent.parent

                elif new_node == new_node.parent.right:
                    new_node = new_node.parent
                    self._left_rotate(new_node)

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

                if uncle.color == "red":
                    new_node.parent.color = "black"
                    uncle.color = "black"
                    new_node.parent.parent.color = "red"
                    new_node = new_node.parent.parent

                elif new_node == new_node.parent.left:
                    new_node = new_node.parent
                    self._right_rotate(new_node)

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

        self.root.color = "black"

    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