【每日算法】Day 5-1：红黑树深入解析——从理论到C++手写实现

攻克高阶数据结构！今日深入解析红黑树的核心原理与实现细节，结合插入删除全流程演示与代码实现，彻底掌握这一高效平衡树的底层逻辑。

一、红黑树核心性质

红黑树（Red-Black Tree） 是一种自平衡二叉搜索树，通过颜色约束和旋转操作维持平衡，满足以下规则：

1. 颜色特性：每个节点非红即黑

2. 根节点特性：根节点必须为黑

3. 叶子特性：所有叶子节点（NIL）为黑

4. 红色节点特性：红节点的子节点必须为黑

5. 黑高一致性：任意节点到叶子路径的黑节点数相同

平衡优势：

• 最坏情况时间复杂度：O(log n)（查找/插入/删除）

• 相比AVL树：放宽平衡条件减少旋转次数

---

二、红黑树节点定义（C++）

enum Color { RED, BLACK };

template <typename T>
struct RBNode {
    T data;
    Color color;
    RBNode* parent;
    RBNode* left;
    RBNode* right;
    
    RBNode(T val, Color c = RED, 
           RBNode* p = nullptr, 
           RBNode* l = nullptr, 
           RBNode* r = nullptr)
        : data(val), color(c), parent(p), left(l), right(r) {}
};

三、核心操作详解

1. 旋转操作（平衡基础）

左旋代码实现：

template <typename T>
void leftRotate(RBNode<T>* x, RBNode<T>*& root) {
    RBNode<T>* y = x->right;      // 获取右子节点
    x->right = y->left;           // y的左子树变为x的右子树
    
    if (y->left != nullptr)
        y->left->parent = x;
    
    y->parent = x->parent;        // 更新父节点关系
    
    if (x->parent == nullptr)
        root = y;
    else if (x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;
    
    y->left = x;                  // x成为y的左子节点
    x->parent = y;
}

2. 插入操作（五类情况处理）

插入流程：

1. 按二叉搜索树规则插入新节点（初始颜色为红）

2. 根据叔节点颜色调整树结构

   • Case 1：叔节点为红 → 颜色翻转

   • Case 2：叔节点为黑且新节点为右子 → 左旋父节点

   • Case 3：叔节点为黑且新节点为左子 → 右旋祖父节点并变色

插入调整代码片段：

template <typename T>
void fixInsert(RBNode<T>* z, RBNode<T>*& root) {
    while (z != root && z->parent->color == RED) {
        RBNode<T>* uncle = nullptr;
        if (z->parent == z->parent->parent->left) { // 父节点是左子
            uncle = z->parent->parent->right;
            if (uncle && uncle->color == RED) {     // Case 1
                z->parent->color = BLACK;
                uncle->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            } else {
                if (z == z->parent->right) {        // Case 2
                    z = z->parent;
                    leftRotate(z, root);
                }
                z->parent->color = BLACK;           // Case 3
                z->parent->parent->color = RED;
                rightRotate(z->parent->parent, root);
            }
        } else { // 对称处理父节点为右子的情况 }
    }
    root->color = BLACK; // 确保根节点为黑
}

3. 删除操作（七类情况处理）

删除流程：

1. 执行标准BST删除

2. 若删除节点为黑，触发平衡调整

   • Case 1：兄弟节点为红 → 旋转父节点

   • Case 2：兄弟节点为黑且其子节点均为黑 → 颜色调整

   • Case 3/4：兄弟节点的左子红或右子红 → 旋转与变色

删除调整代码片段：

template <typename T>
void fixDelete(RBNode<T>* x, RBNode<T>*& root) {
    while (x != root && x->color == BLACK) {
        RBNode<T>* sibling = nullptr;
        if (x == x->parent->left) {
            sibling = x->parent->right;
            if (sibling->color == RED) { // Case 1
                sibling->color = BLACK;
                x->parent->color = RED;
                leftRotate(x->parent, root);
                sibling = x->parent->right;
            }
            if (sibling->left->color == BLACK && 
                sibling->right->color == BLACK) { // Case 2
                sibling->color = RED;
                x = x->parent;
            } else {
                if (sibling->right->color == BLACK) { // Case 3
                    sibling->left->color = BLACK;
                    sibling->color = RED;
                    rightRotate(sibling, root);
                    sibling = x->parent->right;
                }
                sibling->color = x->parent->color;  // Case 4
                x->parent->color = BLACK;
                sibling->right->color = BLACK;
                leftRotate(x->parent, root);
                x = root;
            }
        } else { // 对称处理右子情况 }
    }
    x->color = BLACK;
}

四、红黑树 vs AVL树

特性	红黑树	AVL树
平衡标准	宽松（黑高一致）	严格（左右子树高度差≤1）
旋转频率	较低	较高
插入/删除效率	更优（适合频繁修改场景）	稍差
查找效率	平均O(log n)	更优（严格平衡）
应用场景	C++ map/set, Java TreeMap	数据库索引等查找密集型场景

---

五、大厂真题实战

真题1：手写红黑树核心接口（某大厂2023面试）

要求实现：

• insert(int key)

• delete(int key)

• search(int key)

评分要点：

1. 正确维护红黑树性质

2. 处理所有插入/删除的边界条件

3. 代码可读性与注释质量

---

真题2：区间统计问题（某大厂2024笔试）

题目描述：
设计数据结构，支持快速查询区间[L, R]内的元素个数
红黑树扩展解法：

struct AugNode {
    int key, size; // size维护子树节点数
    Color color;
    AugNode *left, *right, *parent;
    
    void updateSize() {
        size = 1 + left->size + right->size;
    }
};

int countRange(AugNode* root, int L, int R) {
    if (!root) return 0;
    if (root->key > R) 
        return countRange(root->left, L, R);
    if (root->key < L) 
        return countRange(root->right, L, R);
    return 1 + countRange(root->left, L, R) 
             + countRange(root->right, L, R);
}

六、常见误区与调试技巧

1. NIL节点处理：未正确初始化NIL节点导致空指针异常

2. 颜色翻转遗漏：插入后未检查祖父节点引发连续红节点

3. 旋转后未更新父指针：导致树结构断裂

4. 删除时的兄弟节点误判：未正确处理兄弟节点的颜色变化

5. 调试建议：

   • 实现树形打印函数可视化结构

   • 添加断言检查红黑树性质

   • 逐步验证插入/删除后的黑高

---

七、总结与扩展

红黑树核心价值：

• 在动态数据集上保证高效操作

• 通过颜色标记减少平衡开销

• 广泛应用于系统级软件开发

扩展思考：

1. 如何实现线程安全的红黑树？

2. 红黑树在Linux内核中的具体应用场景？

3. 如何扩展红黑树支持区间查询与统计操作？