红黑树：像“魔术师”一样平衡一切！
一、红黑树是啥？——“自动平衡”的魔术
想象你正在看一场魔术表演，魔术师用一只手就能让一堆混乱的牌瞬间变得有序。红黑树（Red-Black Tree） 就像是这样一个魔术师，它能够自动地调整自己，确保在插入或删除节点之后依然保持相对平衡的状态，从而保证了高效的查找、插入和删除操作。
核心思想：通过颜色标记和特定的旋转规则，在插入和删除节点时保持树的高度尽可能小，以保证操作的时间复杂度为 O(log n)。
二、红黑树 vs 普通二叉查找树——“魔术师” vs “杂技演员”
红黑树和普通的二叉查找树就像是两个不同的表演者：
- 红黑树：
- “我有魔法，即使插入或删除节点也能保持平衡！”
- 普通二叉查找树：
- “我只能按顺序排列，但容易变得不平衡。”
区别：
- 红黑树：自我平衡，适合动态数据集
- 普通二叉查找树：可能因数据分布不均导致性能下降
举个🌰：
比如一个按顺序插入的序列 [1, 2, 3, 4, 5]：
- 普通二叉查找树：可能会变成一条链表，查找效率变为 O(n)
- 红黑树：始终保持相对平衡，查找效率保持 O(log n)
三、红黑树的关键特性
3.1 特性概述
- 每个节点要么是红色，要么是黑色。
- 根节点必须是黑色。
- 所有叶子节点（NIL节点，通常视为外部节点）都是黑色。
- 如果一个节点是红色，则它的两个子节点都必须是黑色（即没有连续的红色节点）。
- 从任一节点到其每个叶子的所有路径都包含相同数量的黑色节点。
3.2 示例图解
假设我们有一个简单的红黑树结构：
13B
/ \
8R 17B
/ \ \
6B 11B 25R
- 黑色节点：13, 6, 11, 17
- 红色节点：8, 25
四、插入与删除——“魔术师”的秘密武器
4.1 插入操作
插入新节点后，需要进行一系列的重着色和旋转操作来恢复红黑树的性质。
步骤概要：
- 标准二叉查找树插入：将新节点插入到合适位置。
- 重着色：根据情况调整节点的颜色。
- 旋转：左旋或右旋以恢复树的平衡。
4.2 删除操作
删除节点同样需要一系列复杂的操作来维持红黑树的平衡性。
步骤概要：
- 找到并删除目标节点。
- 调整树结构：通过重着色和旋转来恢复红黑树的性质。
五、代码实现——三种语言的“魔术表演”
为了满足不同语言爱好者的需求，我们用 Java、Python 和 C++ 分别实现红黑树的基本插入操作。
5.1 Java 实现
class Node {
int data;
Node left, right, parent;
boolean color;
public Node(int data) {
this.data = data;
this.color = true; // 新节点默认为红色
}
}
public class RedBlackTree {
private Node root;
private void insert(Node node) {
if (root == null) {
root = node;
root.color = false; // 根节点必须为黑色
} else {
insertNode(root, node);
fixInsert(node);
}
}
private void insertNode(Node root, Node node) {
if (node.data < root.data) {
if (root.left == null) {
root.left = node;
node.parent = root;
} else {
insertNode(root.left, node);
}
} else if (node.data > root.data) {
if (root.right == null) {
root.right = node;
node.parent = root;
} else {
insertNode(root.right, node);
}
}
}
private void fixInsert(Node node) {
Node uncle;
while (node != root && node.parent.color == true) {
if (node.parent == node.parent.parent.left) {
uncle = node.parent.parent.right;
if (uncle != null && uncle.color == true) {
node.parent.color = false;
uncle.color = false;
node.parent.parent.color = true;
node = node.parent.parent;
} else {
if (node == node.parent.right) {
node = node.parent;
leftRotate(node);
}
node.parent.color = false;
node.parent.parent.color = true;
rightRotate(node.parent.parent);
}
} else {
uncle = node.parent.parent.left;
if (uncle != null && uncle.color == true) {
node.parent.color = false;
uncle.color = false;
node.parent.parent.color = true;
node = node.parent.parent;
} else {
if (node == node.parent.left) {
node = node.parent;
rightRotate(node);
}
node.parent.color = false;
node.parent.parent.color = true;
leftRotate(node.parent.parent);
}
}
}
root.color = false;
}
private void leftRotate(Node x) {
Node y = x.right;
x.right = y.left;
if (y.left != null) y.left.parent = x;
y.parent = x.parent;
if (x.parent == null) root = y;
else if (x == x.parent.left) x.parent.left = y;
else x.parent.right = y;
y.left = x;
x.parent = y;
}
private void rightRotate(Node y) {
Node x = y.left;
y.left = x.right;
if (x.right != null) x.right.parent = y;
x.parent = y.parent;
if (y.parent == null) root = x;
else if (y == y.parent.right) y.parent.right = x;
else y.parent.left = x;
x.right = y;
y.parent = x;
}
public static void main(String[] args) {
RedBlackTree tree = new RedBlackTree();
tree.insert(new Node(10));
tree.insert(new Node(20));
tree.insert(new Node(30));
// 继续插入更多节点...
}
}
5.2 Python 实现
class Node:
def __init__(self, data):
self.data = data
self.color = True # 新节点默认为红色
self.left = None
self.right = None
self.parent = None
class RedBlackTree:
def __init__(self):
self.root = None
def insert(self, data):
node = Node(data)
if not self.root:
self.root = node
self.root.color = False # 根节点必须为黑色
else:
self._insert_node(self.root, node)
self._fix_insert(node)
def _insert_node(self, root, node):
if node.data < root.data:
if not root.left:
root.left = node
node.parent = root
else:
self._insert_node(root.left, node)
else:
if not root.right:
root.right = node
node.parent = root
else:
self._insert_node(root.right, node)
def _fix_insert(self, node):
while node != self.root and node.parent.color:
if node.parent == node.parent.parent.left:
uncle = node.parent.parent.right
if uncle and uncle.color:
node.parent.color = False
uncle.color = False
node.parent.parent.color = True
node = node.parent.parent
else:
if node == node.parent.right:
node = node.parent
self._left_rotate(node)
node.parent.color = False
node.parent.parent.color = True
self._right_rotate(node.parent.parent)
else:
uncle = node.parent.parent.left
if uncle and uncle.color:
node.parent.color = False
uncle.color = False
node.parent.parent.color = True
node = node.parent.parent
else:
if node == node.parent.left:
node = node.parent
self._right_rotate(node)
node.parent.color = False
node.parent.parent.color = True
self._left_rotate(node.parent.parent)
self.root.color = False
def _left_rotate(self, x):
y = x.right
x.right = y.left
if y.left: y.left.parent = x
y.parent = x.parent
if not x.parent: self.root = y
elif x == x.parent.left: x.parent.left = y
else: x.parent.right = y
y.left = x
x.parent = y
def _right_rotate(self, y):
x = y.left
y.left = x.right
if x.right: x.right.parent = y
x.parent = y.parent
if not y.parent: self.root = x
elif y == y.parent.right: y.parent.right = x
else: y.parent.left = x
x.right = y
y.parent = x
if __name__ == "__main__":
tree = RedBlackTree()
tree.insert(10)
tree.insert(20)
tree.insert(30)
# 继续插入更多节点...
5.3 C++ 实现
#include <iostream>
using namespace std;
struct Node {
int data;
bool color;
Node *left, *right, *parent;
Node(int data) : data(data), color(true), left(nullptr), right(nullptr), parent(nullptr) {}
};
class RedBlackTree {
private:
Node* root;
void insert(Node* node) {
if (!root) {
root = node;
root->color = false;
} else {
insertNode(root, node);
fixInsert(node);
}
}
void insertNode(Node* root, Node* node) {
if (node->data < root->data) {
if (!root->left) {
root->left = node;
node->parent = root;
} else {
insertNode(root->left, node);
}
} else {
if (!root->right) {
root->right = node;
node->parent = root;
} else {
insertNode(root->right, node);
}
}
}
void fixInsert(Node* node) {
Node* uncle;
while (node != root && node->parent->color) {
if (node->parent == node->parent->parent->left) {
uncle = node->parent->parent->right;
if (uncle && uncle->color) {
node->parent->color = false;
uncle->color = false;
node->parent->parent->color = true;
node = node->parent->parent;
} else {
if (node == node->parent->right) {
node = node->parent;
leftRotate(node);
}
node->parent->color = false;
node->parent->parent->color = true;
rightRotate(node->parent->parent);
}
} else {
uncle = node->parent->parent->left;
if (uncle && uncle->color) {
node->parent->color = false;
uncle->color = false;
node->parent->parent->color = true;
node = node->parent->parent;
} else {
if (node == node->parent->left) {
node = node->parent;
rightRotate(node);
}
node->parent->color = false;
node->parent->parent->color = true;
leftRotate(node->parent->parent);
}
}
}
root->color = false;
}
void leftRotate(Node* x) {
Node* y = x->right;
x->right = y->left;
if (y->left) y->left->parent = x;
y->parent = x->parent;
if (!x->parent) root = y;
else if (x == x->parent->left) x->parent->left = y;
else x->parent->right = y;
y->left = x;
x->parent = y;
}
void rightRotate(Node* y) {
Node* x = y->left;
y->left = x->right;
if (x->right) x->right->parent = y;
x->parent = y->parent;
if (!y->parent) root = x;
else if (y == y->parent->right) y->parent->right = x;
else y->parent->left = x;
x->right = y;
y->parent = x;
}
public:
RedBlackTree() : root(nullptr) {}
void insert(int data) {
insert(new Node(data));
}
};
int main() {
RedBlackTree tree;
tree.insert(10);
tree.insert(20);
tree.insert(30);
// 继续插入更多节点...
return 0;
}
六、总结——像“魔术师”一样平衡一切！
红黑树就像一位神奇的魔术师，能够在动态变化的数据集中保持自身的平衡，确保高效的操作性能。无论是插入还是删除节点，红黑树都能通过巧妙的颜色标记和旋转操作，确保树的高度尽可能小，从而保证了 O(log n) 的时间复杂度。
希望这篇博客能帮助你更好地理解红黑树的工作原理及其实际应用。无论是 Java 的严谨、Python 的简洁，还是 C++ 的高性能，红黑树的核心思想始终如一，掌握这些知识将对你的编程技能有很大提升！
适用场景：
- 动态集合的管理
- 高效的插入、删除和查找操作
- 数据库索引
最后提醒：
红黑树虽然强大，但也较为复杂。初学者可能需要多加练习才能熟练掌握。记住，平衡的艺术在于不断调整和优化！
练习题推荐：
- 实现红黑树的删除操作
- 使用红黑树解决实际问题，如排序算法的改进
- 对比红黑树与其他自平衡树（如AVL树）的区别和联系
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
