C++实现红黑树

红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它通过一系列的规则保持树的平衡，以确保插入、删除和查找等操作的时间复杂度始终保持在 O(log n)。

实现红黑树需要定义节点类和红黑树类，并实现插入、删除和查找等操作。以下是一个简单的红黑树的示例实现：

#include <iostream>

// 红黑树节点类
template<typename K, typename V>
struct RBNode {
    K key;
    V value;
    RBNode* parent;
    RBNode* left;
    RBNode* right;
    bool isRed;

    RBNode(K k, V v) : key(k), value(v), parent(nullptr), left(nullptr), right(nullptr), isRed(true) {}
};

// 红黑树类
template<typename K, typename V>
class RBTree {
private:
    RBNode<K, V>* root;

    // 左旋转
    void leftRotate(RBNode<K, V>* x) {
        RBNode<K, V>* y = x->right;
        x->right = y->left;
        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->parent = y;
    }

    // 右旋转
    void rightRotate(RBNode<K, V>* y) {
        RBNode<K, V>* x = y->left;
        y->left = x->right;
        if (x->right != nullptr) {
            x->right->parent = y;
        }
        x->parent = y->parent;
        if (y->parent == nullptr) {
            root = x;
        } else if (y == y->parent->left) {
            y->parent->left = x;
        } else {
            y->parent->right = x;
        }
        x->right = y;
        y->parent = x;
    }

    // 插入辅助函数
    void insertFixup(RBNode<K, V>* z) {
        while (z->parent != nullptr && z->parent->isRed) {
            if (z->parent == z->parent->parent->left) {
                RBNode<K, V>* y = z->parent->parent->right;
                if (y != nullptr && y->isRed) {
                    z->parent->isRed = false;
                    y->isRed = false;
                    z->parent->parent->isRed = true;
                    z = z->parent->parent;
                } else {
                    if (z == z->parent->right) {
                        z = z->parent;
                        leftRotate(z);
                    }
                    z->parent->isRed = false;
                    z->parent->parent->isRed = true;
                    rightRotate(z->parent->parent);
                }
            } else {
                RBNode<K, V>* y = z->parent->parent->left;
                if (y != nullptr && y->isRed) {
                    z->parent->isRed = false;
                    y->isRed = false;
                    z->parent->parent->isRed = true;
                    z = z->parent->parent;
                } else {
                    if (z == z->parent->left) {
                        z = z->parent;
                        rightRotate(z);
                    }
                    z->parent->isRed = false;
                    z->parent->parent->isRed = true;
                    leftRotate(z->parent->parent);
                }
            }
        }
        root->isRed = false;
    }

    // 插入
    void insert(RBNode<K, V>* z) {
        RBNode<K, V>* y = nullptr;
        RBNode<K, V>* x = root;
        while (x != nullptr) {
            y = x;
            if (z->key < x->key) {
                x = x->left;
            } else {
                x = x->right;
            }
        }
        z->parent = y;
        if (y == nullptr) {
            root = z;
        } else if (z->key < y->key) {
            y->left = z;
        } else {
            y->right = z;
        }
        z->left = nullptr;
        z->right = nullptr;
        z->isRed = true;
        insertFixup(z);
    }

    // 查找辅助函数
    RBNode<K, V>* find(K key) {
        RBNode<K, V>* current = root;
        while (current != nullptr) {
            if (key < current->key) {
                current = current->left;
            } else if (key > current->key) {
                current = current->right;
            } else {
                return current;
            }
        }
        return nullptr;
    }

public:
    RBTree() : root(nullptr) {}

    ~RBTree() {
        // 在这里添加删除树的代码
    }

    // 插入键值对
    void insert(K key, V value) {
        RBNode<K, V>* newNode = new RBNode<K, V>(key, value);
        insert(newNode);
    }

    // 查找键对应的值
    V find(K key) {
        RBNode<K, V>* node = find(key);
        if (node != nullptr) {
            return node->value;
        } else {
            return V(); // 返回默认值
        }
    }

    // 删除键值对
    void erase(K key) {
        // 在这里添加删除键值对的代码
    }
};

int main() {
    // 创建一个红黑树
    RBTree<int, std::string> rbTree;

    // 插入一些键值对
    rbTree.insert(1, "One");
    rbTree.insert(2, "Two");
    rbTree.insert(3, "Three");
    rbTree.insert(4, "Four");
    rbTree.insert(5, "Five");

    // 查找键对应的值并输出
    std::cout << "Value for key 3: " << rbTree.find(3) << std::endl;

    return 0;
}