C++ 红黑树深度解析：原理、旋转与完整实现

3. 插入操作与平衡调整

插入逻辑分为两步：先按二叉搜索树规则找到位置插入新节点，再检查并修复红黑树性质。

3.1 插入策略

1. 空树：直接插入黑色根节点。
2. 非空树：新插入节点默认为红色。如果父节点是黑色，无需调整；如果父节点是红色，则违反规则 3，需要调整。

注意：新增节点设为红色是因为插入黑色会破坏'每条路径黑色节点数相等'的规则，而红色更容易通过变色或旋转修复。

3.2 三种调整情况

当插入导致父子均为红色时，我们需要观察叔叔节点（Parent 的兄弟）的颜色，分三种情况处理：

情况 1：叔叔存在且为红色（变色）

此时祖父节点必为黑色。将父节点和叔叔节点变黑，祖父节点变红。然后将祖父节点视为当前节点继续向上递归调整。

情况 2：叔叔不存在或为黑色，且当前节点与父节点同侧（单旋 + 变色）

例如：左 - 左 或 右 - 右。以祖父节点进行反向旋转，然后交换父节点和祖父节点的颜色（父黑祖红）。

情况 3：叔叔不存在或为黑色，且当前节点与父节点异侧（双旋 + 变色）

例如：左 - 右 或 右 - 左。先以父节点为轴进行一次旋转，转化为情况 2，再进行第二次旋转和变色。

关键点：无论哪种情况，最终都要确保根节点是黑色的。如果调整过程中根节点变成了红色，最后强制置黑即可。

3.3 旋转实现

旋转是维持树结构的关键，分为左旋和右旋。旋转后需更新相关节点的父指针和子指针。

// 右旋示例（以 parent 为轴）
void RotateR(Node* parent) {
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    
    parent->_left = subLR;
    if (subLR) subLR->_parent = parent;
    
    Node* parentParent = parent->_parent;
    subL->_right = parent;
    parent->_parent = subL;
    
    if (parent == _root) {
        _root = subL;
        subL->_parent = nullptr;
    } else {
        if (parentParent->_left == parent)
            parentParent->_left = subL;
        else
            parentParent->_right = subL;
        subL->_parent = parentParent;
    }
}

4. 辅助功能与验证

4.1 双重接口设计

对于 Size()、Height() 等操作，用户只需调用公共接口 tree.Size()，内部通过私有递归函数 _Size(root) 实现。这种设计既保证了封装性，又满足了递归需要传递当前节点的需求。

public:
    int Size() { return _Size(_root); }
private:
    int _Size(Node* root) {
        if (root == nullptr) return 0;
        return _Size(root->_left) + _Size(root->_right) + 1;
    }

4.2 验证红黑树

验证比想象中复杂，不能仅看最长路径是否小于最短路径的 2 倍。必须检查所有四条核心规则：

1. 根节点是否为黑。
2. 是否存在连续红节点（前序遍历检查父节点）。
3. 所有路径的黑色节点数量是否一致（记录第一条路径的黑节点数作为基准）。

5. 完整代码示例

以下是完整的头文件实现及测试用例。

RBTree.h

#pragma once
#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std;

enum Color { BLACK, RED };

template<class K, class V>
struct RBTreeNode {
    pair<K, V> _kv;
    RBTreeNode* _left;
    RBTreeNode* _right;
    RBTreeNode* _parent;
    Color _col;

    RBTreeNode(const pair<K, V>& kv)
        :_kv(kv), _left(nullptr), _right(nullptr), _parent(nullptr), _col(RED) {}
};

template<class K, class V>
struct RBTree {
    typedef RBTreeNode<K, V> Node;

    bool Insert(const pair<K, V>& kv) {
        if (_root == nullptr) {
            _root = new Node(kv);
            _root->_col = BLACK;
            return true;
        }

        Node* parent = nullptr;
        Node* cur = _root;
        while (cur) {
            if (cur->_kv.first < kv.first) {
                parent = cur;
                cur = cur->_right;
            } else if (cur->_kv.first > kv.first) {
                parent = cur;
                cur = cur->_left;
            } else {
                return false; // 键已存在
            }
        }

        cur = new Node(kv);
        cur->_col = RED;
        if (parent->_kv.first < kv.first)
            parent->_right = cur;
        else
            parent->_left = cur;
        cur->_parent = parent;

        // 修复红黑树性质
        while (parent && parent->_col == RED) {
            Node* grandfather = parent->_parent;
            if (grandfather->_left == parent) {
                Node* uncle = grandfather->_right;
                if (uncle && uncle->_col == RED) {
                    // 情况 1：变色
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                } else {
                    // 情况 2/3：旋转 + 变色
                    if (cur == parent->_left) {
                        RotateR(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    } else {
                        RotateL(parent);
                        RotateR(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    break;
                }
            } else {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_col == RED) {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                } else {
                    if (cur == parent->_right) {
                        RotateL(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    } else {
                        RotateR(parent);
                        RotateL(grandfather);
                        grandfather->_col = RED;
                        cur->_col = BLACK;
                    }
                    break;
                }
            }
        }
        _root->_col = BLACK;
        return true;
    }

    void RotateR(Node* parent) {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR) subLR->_parent = parent;
        Node* parentParent = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;
        if (parent == _root) {
            _root = subL;
            subL->_parent = nullptr;
        } else {
            if (parentParent->_left == parent)
                parentParent->_left = subL;
            else
                parentParent->_right = subL;
            subL->_parent = parentParent;
        }
    }

    void RotateL(Node* parent) {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        parent->_right = subRL;
        if (subRL) subRL->_parent = parent;
        Node* parentParent = parent->_parent;
        subR->_left = parent;
        parent->_parent = subR;
        if (parentParent == nullptr) {
            _root = subR;
            subR->_parent = nullptr;
        } else {
            if (parent == parentParent->_left)
                parentParent->_left = subR;
            else
                parentParent->_right = subR;
            subR->_parent = parentParent;
        }
    }

    void InOrder() {
        _InOrder(_root);
        cout << endl;
    }

    Node* Find(const K& key) {
        Node* cur = _root;
        while (cur) {
            if (cur->_kv.first < key)
                cur = cur->_right;
            else if (cur->_kv.first > key)
                cur = cur->_left;
            else
                return cur;
        }
        return nullptr;
    }

    bool IsBalanceTree() {
        if (_root && _root->_col == RED) return false;
        int left_bn = 0;
        Node* cur = _root;
        while (cur) {
            if (cur->_col == BLACK) left_bn++;
            cur = cur->_left;
        }
        return _Checkcolor(_root, 0, left_bn);
    }

    int Height() { return _Height(_root); }
    int Size() { return _Size(_root); }

private:
    int _Size(Node* root) {
        if (root == nullptr) return 0;
        return _Size(root->_left) + _Size(root->_right) + 1;
    }

    int _Height(Node* root) {
        if (root == nullptr) return 0;
        int leftHeight = _Height(root->_left);
        int rightHeight = _Height(root->_right);
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

    bool _Checkcolor(Node* root, int root_cur_bn, const int left_bn) {
        if (root == nullptr) {
            if (root_cur_bn != left_bn) {
                cout << "黑色节点的数量不相等" << endl;
                return false;
            }
            return true;
        }
        if (root->_col == BLACK)
            root_cur_bn++;
        if (root->_col == RED && root->_parent && root->_parent->_col == RED) {
            cout << root->_kv.first << "存在连续的红色节点" << endl;
            return false;
        }
        return _Checkcolor(root->_left, root_cur_bn, left_bn) &&
               _Checkcolor(root->_right, root_cur_bn, left_bn);
    }

    int _InOrder(Node* root) {
        if (root == nullptr) return 0;
        _InOrder(root->_left);
        cout << root->_kv.first << " ";
        _InOrder(root->_right);
        return 0;
    }

    Node* _root = nullptr;
};

Tree.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include "RBTree.h"

using namespace std;

void TestRBTree1() {
    RBTree<int, int> t;
    int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
    for (auto e : a) {
        t.Insert({ e, e });
        cout << "Insert:" << e << "->";
        t.InOrder();
    }
    t.InOrder();
}

void TestRBTree2() {
    const int N = 1000000;
    vector<int> v;
    v.reserve(N);
    srand(time(0));
    for (size_t i = 0; i < N; i++) {
        v.push_back(rand() + i);
    }
    size_t begin2 = clock();
    RBTree<int, int> t;
    for (auto e : v) {
        t.Insert(make_pair(e, e));
    }
    size_t end2 = clock();
    cout << "Insert Time:" << end2 - begin2 << endl;
    cout << "Is Balanced:" << t.IsBalanceTree() << endl;
    cout << "Height:" << t.Height() << endl;
    cout << "Size:" << t.Size() << endl;
}

int main() {
    // TestRBTree1();
    TestRBTree2();
    return 0;
}

6. 总结

红黑树通过巧妙的颜色约束和旋转机制，在保持高效查找的同时降低了维护平衡的成本。虽然删除操作比插入更复杂，但本文重点阐述了插入逻辑，这是理解红黑树平衡机制的基础。若需深入删除细节，建议参考《算法导论》或《STL 源码剖析》。