数据结构：红黑树的奥秘与魅力

前端

2023-09-15 08:16:19

红黑树：一种平衡高效的二叉搜索树

什么是红黑树？

红黑树是一种平衡的二叉搜索树，它通过引入一个额外的“颜色”属性来维持树的平衡。这种数据结构将每个节点标记为红色或黑色，并通过对红色节点和黑色节点的数量进行限制来确保树的高度始终保持在对数级别，从而保证了快速查找、插入和删除操作。

红黑树的五条规则

为了确保红黑树的平衡性和稳定性，它遵循以下五条规则：

节点颜色规则： 每个节点要么是红色的，要么是黑色的。
根节点颜色规则： 根节点必须是黑色的。
每个叶节点的颜色规则： 所有的叶节点都是黑色的。
红色节点的子节点颜色规则： 红色的节点只能有一个红色的子节点。
黑色节点的子节点颜色规则： 黑色的节点可以有两个红色子节点。

红黑树的优点

作为一种高效且平衡的二叉搜索树，红黑树具有以下优点：

快速的查找、插入和删除操作： 红黑树的高度始终保持在对数级别，这使得查找、插入和删除操作的时间复杂度为O(log n)。
良好的平衡性： 红黑树通过对红色节点和黑色节点的数量进行限制，确保了树的高度始终保持在对数级别，从而保证了良好的平衡性。
广泛的应用场景： 红黑树广泛应用于各种需要快速查找、插入和删除操作的数据结构中，例如数据库索引、文件系统和图形处理等。

红黑树的实现

以下代码示例展示了如何用Python实现红黑树：

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

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

    def _insert_helper(self, new_node, current_node):
        if new_node.key < current_node.key:
            if current_node.left is None:
                current_node.left = new_node
            else:
                self._insert_helper(new_node, current_node.left)
        else:
            if current_node.right is None:
                current_node.right = new_node
            else:
                self._insert_helper(new_node, current_node.right)

        self._fix_insert(new_node)

    def _fix_insert(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
                else:
                    if new_node == new_node.parent.right:
                        new_node = new_node.parent
                        self._left_rotate(new_node)
                    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
                else:
                    if new_node == new_node.parent.left:
                        new_node = new_node.parent
                        self._right_rotate(new_node)
                    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
        else:
            if 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
        else:
            if node == node.parent.right:
                node.parent.right = left_child
            else:
                node.parent.left = left_child
        left_child.right = node
        node.parent = left_child

    def search(self, key):
        return self._search(key, self.root)

    def _search(self, key, current_node):
        if current_node is None:
            return None
        if key == current_node.key:
            return current_node
        elif key < current_node.key:
            return self._search(key, current_node.left)
        else:
            return self._search(key, current_node.right)

    def delete(self, key):
        node_to_delete = self._search(key, self.root)
        self._delete(node_to_delete)

    def _delete(self, node_to_delete):
        if node_to_delete.left is None and node_to_delete.right is None:
            self._delete_leaf(node_to_delete)
        elif node_to_delete.left is None:
            self._delete_one_child(node_to_delete, node_to_delete.right)
        elif node_to_delete.right is None:
            self._delete_one_child(node_to_delete, node_to_delete.left)
        else:
            self._delete_two_children(node_to_delete)

    def _delete_leaf(self, node_to_delete):
        if node_to_delete == self.root:
            self.root = None
        elif node_to_delete == node_to_delete.parent.left:
            node_to_delete.parent.left = None
        else:
            node_to_delete.parent.right = None

    def _delete_one_child(self, node_to_delete, child):
        if node_to_delete == self.root:
            self.root = child
        elif node_to_delete == node_to_delete.parent.left:
            node_to_delete.parent.left = child
        else:
            node_to_delete.parent.right = child
        child.parent = node_to_delete.parent

    def _delete_two_children(self, node_to_delete):
        successor = self._get_successor(node_to_delete)
        node_to_delete.key = successor.key
        node_to_delete.value = successor.value
        self._delete_leaf(successor)

    def _get_successor(self, node):
        # ...