为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 红黑树入门详解：快速掌握红黑树基础知识

红黑树入门详解：快速掌握红黑树基础知识

标签：
算法与数据结构
概述

红黑树是一种自平衡二叉查找树，结合了高效查找性能和平衡特性。红黑树通过节点颜色属性（红色或黑色）和特定性质保持平衡，确保了高效的操作性能。红黑树广泛应用于各种编程语言的标准集合类库中，适用于需要高效查找、插入和删除操作的场景。

红黑树的基本概念

定义与性质

红黑树是一种自平衡二叉查找树，它结合了二叉查找树的高效查找性能和平衡树的平衡特性。红黑树的每个节点都有一个额外的属性：颜色，可以是红色或黑色。红黑树的性质保证了对于任何有效的红黑树，从根到叶子的最长路径不会超过最短路径的两倍。具体来说，红黑树有以下5个性质：

  1. 每个节点要么是黑色，要么是红色。
  2. 根节点是黑色。
  3. 所有叶子节点（NIL节点）是黑色。
  4. 如果一个节点是红色的，则它的子节点必须是黑色的。
  5. 从任一节点到其所有叶子节点的简单路径上，黑色节点的数量相同。

这些性质保证了红黑树的平衡性，从而使得红黑树的查找、插入和删除操作的最坏情况时间复杂度为 (O(\log n))。

红黑树的起源与应用场景

红黑树的概念最早由Rudolf Bayer在1972年提出，并被命名为“对称二叉B树”。后来，在1978年，Robert Sedgewick将红黑树的概念引入计算机科学领域。红黑树因其良好的自平衡特性，被广泛应用于许多编程语言的标准集合类库中，如Java中的HashMap和C++中的STL库中的map和set。红黑树特别适用于需要高效查找、插入和删除操作的数据结构。

示例代码

下面是一个简单的红黑树节点定义的示例：

class Node:
    def __init__(self, key, color='RED'):
        self.key = key
        self.color = color
        self.left = None
        self.right = None
        self.parent = None

红黑树的结构特点

各节点的定义与角色

红黑树中的每个节点除了包含键值、左子树、右子树和父节点外，还包含一个表示颜色的属性。具体角色如下：

  1. 键值（Key）：节点所存储的数据。
  2. 颜色（Color）：表示节点的颜色，可以是红色或黑色。
  3. 左子树（Left）：指向当前节点的左子节点。
  4. 右子树（Right）：指向当前节点的右子节点。
  5. 父节点（Parent）：指向当前节点的父节点。

通过这些属性，红黑树可以保持其平衡性，确保树的高度不会超过 (O(\log n))。

红黑树的性质与保持条件

为了保持红黑树的平衡性，必须确保以下性质始终成立：

  1. 颜色性质：每个节点要么是红色，要么是黑色。
  2. 根节点性质：根节点是黑色。
  3. 叶子节点性质：所有叶子节点都是黑色。
  4. 相邻节点性质：如果一个节点是红色的，则它的子节点必须是黑色的。
  5. 平衡性质：从任一节点到其所有叶子节点的简单路径上，黑色节点的数量相同。

这些性质通过适当的插入和删除操作来维护。插入操作可能破坏这些性质，因此需要进行一系列的调整来恢复平衡。同样，删除操作也可能破坏这些性质，因此也需要进行调整。

红黑树的插入操作

插入节点的基本步骤

插入操作的步骤如下：

  1. 插入新节点：将新节点插入到二叉查找树中，并初始化颜色为红色。
  2. 调整树结构：调整树结构以保持红黑树的性质。

插入后维护红黑树性质的方法

插入新节点后，需要进行以下操作来恢复红黑树的性质：

  1. 根节点调整：如果新插入的节点是根节点，则将其颜色设置为黑色。
  2. 父节点调整：如果新插入节点的父节点是黑色，则不需要进行额外调整。
  3. 父节点为红色的调整：如果新插入节点的父节点是红色，则需要进行调整，可能涉及到祖父节点和叔节点。有几种可能的调整方式：
    • 左旋调整：如果新插入节点是其父节点的右子节点且父节点是祖父节点的左子节点，则进行左旋操作。
    • 右旋调整：如果新插入节点是其父节点的左子节点且父节点是祖父节点的右子节点，则进行右旋操作。
    • 颜色调整：如果新插入节点是其父节点的左子节点且父节点是祖父节点的左子节点或右子节点，则进行颜色调整。

示例代码

下面是一个简单的红黑树插入操作的示例：

def insert(root, key):
    new_node = Node(key)
    if not root:
        new_node.color = 'BLACK'
        return new_node
    else:
        if key < root.key:
            root.left = insert(root.left, key)
            root.left.parent = root
        else:
            root.right = insert(root.right, key)
            root.right.parent = root
        return fix_insert(root, new_node)

def fix_insert(node, new_node):
    if not node.parent:  # 如果插入的是根节点
        node.color = 'BLACK'
        return node
    if node.parent.color == 'BLACK':  # 如果父节点是黑色，不需要额外调整
        return node
    uncle = get_uncle(node)
    if uncle and uncle.color == 'RED':  # 如果叔叔节点是红色
        node.parent.color = 'BLACK'
        uncle.color = 'BLACK'
        node.grandparent.color = 'RED'
        return fix_insert(node.grandparent, new_node)
    else:
        if node == node.parent.right:
            node = rotate_left(node.parent)
            new_node = node.left
        node.parent.color = 'BLACK'
        node.grandparent.color = 'RED'
        return rotate_right(node.grandparent)

def rotate_left(node):
    right_child = node.right
    node.right = right_child.left
    if right_child.left:
        right_child.left.parent = node
    right_child.parent = node.parent
    if not node.parent:
        node.grandparent = None
    elif node == node.parent.left:
        node.parent.left = right_child
    else:
        node.parent.right = right_child
    right_child.left = node
    node.parent = right_child
    return right_child

def rotate_right(node):
    left_child = node.left
    node.left = left_child.right
    if left_child.right:
        left_child.right.parent = node
    left_child.parent = node.parent
    if not node.parent:
        node.grandparent = None
    elif node == node.parent.right:
        node.parent.right = left_child
    else:
        node.parent.left = left_child
    left_child.right = node
    node.parent = left_child
    return left_child

def get_uncle(node):
    if not node.parent.parent:
        return None
    if node.parent == node.parent.parent.left:
        return node.parent.parent.right
    else:
        return node.parent.parent.left

红黑树的删除操作

删除节点的基本步骤

删除操作的步骤如下：

  1. 查找节点：查找并定位要删除的节点。
  2. 删除节点：删除节点，并根据节点类型进行调整。
  3. 调整树结构：调整树结构以保持红黑树的性质。

删除后维护红黑树性质的方法

删除节点后，需要进行以下操作来恢复红黑树的性质：

  1. 根节点调整：如果删除的节点是根节点，则不需要调整。
  2. 删除节点为黑色的调整：如果删除的节点是黑色，则需要进行调整，可能涉及到兄弟节点。有几种可能的调整方式：
    • 兄弟节点为红色的调整：如果兄弟节点是红色，则进行颜色调整。
    • 兄弟节点为黑色且兄弟节点的子节点是黑色的调整：如果兄弟节点是黑色且兄弟节点的子节点是黑色，则进行旋转和颜色调整。
    • 兄弟节点为黑色且兄弟节点的子节点是红色的调整：如果兄弟节点是黑色且兄弟节点的子节点是红色，则进行旋转和颜色调整。

示例代码

下面是一个简单的红黑树删除操作的示例：

def delete_node(root, key):
    node_to_delete = search(root, key)
    if not node_to_delete:
        return root
    if not node_to_delete.left or not node_to_delete.right:
        node_replacement = node_to_delete.left or node_to_delete.right
    else:
        node_replacement = get_successor(node_to_delete)
        node_to_delete.key = node_replacement.key
        node_replacement = node_replacement.right
    if not node_replacement:
        if node_to_delete.color == 'BLACK':
            node_to_delete.color = 'RED'
            root = remove_case_1(root, node_to_delete)
        return flip_color(root)
    if node_replacement.color == 'BLACK':
        if node_replacement == node_to_delete.left:
            node_replacement_sibling = node_to_delete.right
            if node_replacement_sibling.color == 'RED':
                node_to_delete.color = 'RED'
                node_replacement_sibling.color = 'BLACK'
                root = rotate_left(root, node_to_delete)
                node_replacement_sibling = node_to_delete.right
            if node_replacement_sibling.left.color == 'BLACK' and node_replacement_sibling.right.color == 'BLACK':
                node_replacement_sibling.color = 'RED'
                root = remove_case_1(root, node_replacement)
            else:
                if node_replacement_sibling.left.color == 'BLACK':
                    node_replacement_sibling.right.color = 'BLACK'
                    node_replacement_sibling = rotate_left(root, node_replacement_sibling)
                    node_replacement_sibling.color = 'RED'
                node_replacement_sibling.left.color = 'BLACK'
                node_replacement_sibling.color = node_to_delete.color
                root = rotate_right(root, node_replacement_sibling)
                node_to_delete.color = 'BLACK'
        else:
            node_replacement_sibling = node_to_delete.left
            if node_replacement_sibling.color == 'RED':
                node_to_delete.color = 'RED'
                node_replacement_sibling.color = 'BLACK'
                root = rotate_right(root, node_to_delete)
                node_replacement_sibling = node_to_delete.left
            if node_replacement_sibling.right.color == 'BLACK' and node_replacement_sibling.left.color == 'BLACK':
                node_replacement_sibling.color = 'RED'
                root = remove_case_1(root, node_replacement)
            else:
                if node_replacement_sibling.right.color == 'BLACK':
                    node_replacement_sibling.left.color = 'BLACK'
                    node_replacement_sibling = rotate_right(root, node_replacement_sibling)
                    node_replacement_sibling.color = 'RED'
                node_replacement_sibling.right.color = 'BLACK'
                node_replacement_sibling.color = node_to_delete.color
                root = rotate_left(root, node_replacement_sibling)
                node_to_delete.color = 'BLACK'
    else:
        node_replacement.color = node_to_delete.color
    if node_to_delete == root:
        root = None
    return root

def search(root, key):
    while root and root.key != key:
        if key < root.key:
            root = root.left
        else:
            root = root.right
    return root

def get_successor(node):
    successor = node.right
    while successor.left:
        successor = successor.left
    return successor

红黑树与二叉查找树的比较

性能与复杂度分析

二叉查找树的查找、插入和删除操作的时间复杂度为 (O(\log n)) 至 (O(n))，取决于树的平衡性。而红黑树通过自平衡机制，可以保证这些操作的时间复杂度始终为 (O(\log n))。因此，红黑树在最坏情况下也能保持高效性。

适用场景比较

二叉查找树适用于需要高效查找和插入的数据结构，但在极端情况下（如完全不平衡），性能会显著下降。红黑树则适用于需要高效查找、插入和删除操作，并且需要保证平衡性的数据结构。因此，红黑树在需要高效操作和平衡性的场景中更为适用。

实际案例：红黑树的应用实例

红黑树在具体数据结构中的应用

红黑树在许多编程语言的标准集合类库中都有应用。例如，Java中的HashMap和C++中的STL库中的map和set都使用了红黑树来实现。这些数据结构在实现高效查找、插入和删除操作时，利用了红黑树的自平衡特性。

如何在实际项目中使用红黑树

在实际项目中，红黑树通常用于需要高效数据操作和保证平衡性的场景。例如，在实现一个高性能的数据结构时，可以使用红黑树来确保数据的高效查找和插入。下面是一个简单的例子，展示了如何在Python中实现一个基于红黑树的数据结构：

class RBTree:
    def __init__(self):
        self.NIL = Node(None, color='BLACK')
        self.root = self.NIL

    def insert(self, key):
        new_node = Node(key)
        if not self.root:
            self.root = new_node
            self.root.color = 'BLACK'
        else:
            self.root = insert(self.root, new_node)
            new_node.color = 'BLACK'

    def delete(self, key):
        node_to_delete = search(self.root, key)
        if not node_to_delete:
            return
        if not node_to_delete.left or not node_to_delete.right:
            node_replacement = node_to_delete.left or node_to_delete.right
        else:
            node_replacement = get_successor(node_to_delete)
            node_to_delete.key = node_replacement.key
            node_replacement = node_replacement.right
        if not node_replacement:
            if node_to_delete.color == 'BLACK':
                node_to_delete.color = 'RED'
                self.root = remove_case_1(self.root, node_to_delete)
            return flip_color(self.root)
        if node_replacement.color == 'BLACK':
            if node_replacement == node_to_delete.left:
                node_replacement_sibling = node_to_delete.right
                if node_replacement_sibling.color == 'RED':
                    node_to_delete.color = 'RED'
                    node_replacement_sibling.color = 'BLACK'
                    self.root = rotate_left(self.root, node_to_delete)
                    node_replacement_sibling = node_to_delete.right
                if node_replacement_sibling.left.color == 'BLACK' and node_replacement_sibling.right.color == 'BLACK':
                    node_replacement_sibling.color = 'RED'
                    self.root = remove_case_1(self.root, node_replacement)
                else:
                    if node_replacement_sibling.left.color == 'BLACK':
                        node_replacement_sibling.right.color = 'BLACK'
                        node_replacement_sibling = rotate_left(self.root, node_replacement_sibling)
                        node_replacement_sibling.color = 'RED'
                    node_replacement_sibling.left.color = 'BLACK'
                    node_replacement_sibling.color = node_to_delete.color
                    self.root = rotate_right(self.root, node_replacement_sibling)
                    node_to_delete.color = 'BLACK'
            else:
                node_replacement_sibling = node_to_delete.left
                if node_replacement_sibling.color == 'RED':
                    node_to_delete.color = 'RED'
                    node_replacement_sibling.color = 'BLACK'
                    self.root = rotate_right(self.root, node_to_delete)
                    node_replacement_sibling = node_to_delete.left
                if node_replacement_sibling.right.color == 'BLACK' and node_replacement_sibling.left.color == 'BLACK':
                    node_replacement_sibling.color = 'RED'
                    self.root = remove_case_1(self.root, node_replacement)
                else:
                    if node_replacement_sibling.right.color == 'BLACK':
                        node_replacement_sibling.left.color = 'BLACK'
                        node_replacement_sibling = rotate_right(self.root, node_replacement_sibling)
                        node_replacement_sibling.color = 'RED'
                    node_replacement_sibling.right.color = 'BLACK'
                    node_replacement_sibling.color = node_to_delete.color
                    self.root = rotate_left(self.root, node_replacement_sibling)
                    node_to_delete.color = 'BLACK'
        else:
            node_replacement.color = node_to_delete.color
        if node_to_delete == self.root:
            self.root = None

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

def search(root, key):
    while root and root.key != key:
        if key < root.key:
            root = root.left
        else:
            root = root.right
    return root

def get_successor(node):
    successor = node.right
    while successor.left:
        successor = successor.left
    return successor

def insert(root, new_node):
    if not root:
        return new_node
    if new_node.key < root.key:
        root.left = insert(root.left, new_node)
        root.left.parent = root
    else:
        root.right = insert(root.right, new_node)
        root.right.parent = root
    return root

def remove_case_1(node, new_node):
    if not node.parent:
        return node
    if node.parent.left == new_node:
        if node.left:
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.left = node.right
            if node.right:
                node.right.parent = node.parent
    else:
        if node.left:
            node.parent.right = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.right
            if node.right:
                node.right.parent = node.parent
    return node

def flip_color(node):
    if not node:
        return node
    node.color = 'RED'
    if node.left and node.left.color == 'RED':
        node.left.color = 'BLACK'
    if node.right and node.right.color == 'RED':
        node.right.color = 'BLACK'
    return node

def rotate_left(node):
    right_child = node.right
    node.right = right_child.left
    if right_child.left:
        right_child.left.parent = node
    right_child.parent = node.parent
    if not node.parent:
        node.grandparent = None
    elif node == node.parent.left:
        node.parent.left = right_child
    else:
        node.parent.right = right_child
    right_child.left = node
    node.parent = right_child
    return right_child

def rotate_right(node):
    left_child = node.left
    node.left = left_child.right
    if left_child.right:
        left_child.right.parent = node
    left_child.parent = node.parent
    if not node.parent:
        node.grandparent = None
    elif node == node.parent.right:
        node.parent.right = left_child
    else:
        node.parent.left = left_child
    left_child.right = node
    node.parent = left_child
    return left_child

总结

红黑树作为一种自平衡的二叉查找树，其高效查找、插入和删除操作以及良好的平衡性使其在许多实际应用中表现出色。通过理解红黑树的基本概念、结构特点、插入和删除操作，可以更好地利用其特性来实现高效的数据结构。在实际项目中，通过Python或C++等编程语言实现红黑树，可以有效地提升数据操作的性能。

点击查看更多内容
发表于 2024.11.04 16:08， 共 41 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

呼如林

手记
篇
粉丝
102
获赞与收藏
363

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消