c/c++｜红黑树｜分析&应用｜锚点

红黑树是一种自平衡的二叉查找树，它保持着良好的平衡，能够在插入和删除等操作后通过一系列旋转和重新着色操作来保持树的平衡。这种平衡性质使得红黑树在搜索、插入和删除等操作的平均和最坏情况下的时间复杂度都是O(log n)。以下是红黑树的一些关键特性和性质：

每个节点要么是红色，要么是黑色。
根节点必须是黑色。
红色节点的子节点必须是黑色（不存在两个相邻的红色节点）。
从任一节点到其每个叶子的所有路径都包含相同数量的黑色节点，这被称为“黑色平衡”或“黑高度”。
红黑树的基本操作包括插入、删除、查找等。其中，插入和删除操作是通过一系列旋转和重新着色来维护红黑树的平衡性。

插入操作：当插入一个新节点时，首先按照二叉查找树的规则找到其应该插入的位置。然后，将新节点插入为红色节点，这样可能会破坏红黑树的某些性质，如颜色相邻节点不能同时为红色。接下来，通过一系列的旋转和重新着色操作来修复这些性质，以确保树的平衡性。

删除操作：删除操作也是通过一系列旋转和重新着色来维护树的平衡性。当删除一个节点时，首先按照二叉查找树的规则找到要删除的节点。然后，根据要删除节点的子节点情况进行不同的处理：如果要删除的节点有零个或一个子节点，直接删除即可；如果要删除的节点有两个子节点，则需要找到其后继节点（即比它大的最小节点），并用后继节点替换原节点，然后再删除后继节点。

查找操作：查找操作和普通的二叉查找树一样，采用递归或迭代的方式从根节点开始逐级查找，直到找到目标节点或到达叶子节点为止。

红黑树的时间复杂度和空间复杂度分析如下：

时间复杂度：在红黑树中，搜索、插入和删除操作的平均和最坏情况下的时间复杂度都是O(log n)，其中n是树中节点的数量。这是因为红黑树保持了良好的平衡性质，使得树的高度保持在O(log n)级别。因此，即使在最坏情况下，搜索、插入和删除操作的性能也是很高效的。

空间复杂度：红黑树的空间复杂度主要取决于节点的数量。每个节点除了存储数据外，还需要存储指向父节点、左子节点和右子节点的指针，以及颜色信息。因此，红黑树的空间复杂度为O(n)，其中n是树中节点的数量。

#include 

enum Color { RED, BLACK };

template 
struct Node {
    T data;
    Node *left, *right, *parent;
    Color color;

    // Constructor
    Node(T data) : data(data), left(nullptr), right(nullptr), parent(nullptr), color(RED) {}
};

template 
class RedBlackTree {
private:
    Node *root;

    // Private methods
    void rotateLeft(Node *&);
    void rotateRight(Node *&);
    void fixInsertion(Node *&);

public:
    // Constructor
    RedBlackTree() : root(nullptr) {}

    // Public methods
    void insert(const T&);
    void printInorder() const;
};

// Rotate left
template 
void RedBlackTree::rotateLeft(Node *&node) {
    Node *rightChild = node->right;
    node->right = rightChild->left;
    
    if (node->right != nullptr)
        node->right->parent = node;

    rightChild->parent = node->parent;

    if (node->parent == nullptr)
        root = rightChild;
    else if (node == node->parent->left)
        node->parent->left = rightChild;
    else
        node->parent->right = rightChild;

    rightChild->left = node;
    node->parent = rightChild;
}

// Rotate right
template 
void RedBlackTree::rotateRight(Node *&node) {
    Node *leftChild = node->left;
    node->left = leftChild->right;
    
    if (node->left != nullptr)
        node->left->parent = node;

    leftChild->parent = node->parent;

    if (node->parent == nullptr)
        root = leftChild;
    else if (node == node->parent->left)
        node->parent->left = leftChild;
    else
        node->parent->right = leftChild;

    leftChild->right = node;
    node->parent = leftChild;
}

// Fix insertion
template 
void RedBlackTree::fixInsertion(Node *&node) {
    Node *parent = nullptr;
    Node *grandparent = nullptr;

    while (node != root && node->color != BLACK && node->parent->color == RED) {
        parent = node->parent;
        grandparent = parent->parent;

        // Case : Parent is left child of Grandparent
        if (parent == grandparent->left) {
            Node *uncle = grandparent->right;

            // Case : Uncle is RED, only recoloring required
            if (uncle != nullptr && uncle->color == RED) {
                grandparent->color = RED;
                parent->color = BLACK;
                uncle->color = BLACK;
                node = grandparent;
            } else {
                // Case : Node is right child of Parent
                if (node == parent->right) {
                    rotateLeft(parent);
                    node = parent;
                    parent = node->parent;
                }

                // Case : Node is left child of Parent
                rotateRight(grandparent);
                std::swap(parent->color, grandparent->color);
                node = parent;
            }
        } else {
            // Case : Parent is right child of Grandparent
            Node *uncle = grandparent->left;

            // Case : Uncle is RED, only recoloring required
            if (uncle != nullptr && uncle->color == RED) {
                grandparent->color = RED;
                parent->color = BLACK;
                uncle->color = BLACK;
                node = grandparent;
            } else {
                // Case : Node is left child of Parent
                if (node == parent->left) {
                    rotateRight(parent);
                    node = parent;
                    parent = node->parent;
                }

                // Case : Node is right child of Parent
                rotateLeft(grandparent);
                std::swap(parent->color, grandparent->color);
                node = parent;
            }
        }
    }

    root->color = BLACK;
}

// Insert node into the tree
template 
void RedBlackTree::insert(const T& data) {
    Node *newNode = new Node(data);

    Node *parent = nullptr;
    Node *current = root;

    while (current != nullptr) {
        parent = current;
        if (newNode->data < current->data)
            current = current->left;
        else
            current = current->right;
    }

    newNode->parent = parent;

    if (parent == nullptr)
        root = newNode;
    else if (newNode->data < parent->data)
        parent->left = newNode;
    else
        parent->right = newNode;

    fixInsertion(newNode);
}

// Inorder traversal
template 
void inorderHelper(Node *root) {
    if (root == nullptr) return;
    inorderHelper(root->left);
    std::cout << root->data << " ";
    inorderHelper(root->right);
}

// Print tree in inorder
template 
void RedBlackTree::printInorder() const {
    inorderHelper(root);
}

// Test
int main() {
    RedBlackTree tree;

    tree.insert(10);
    tree.insert(20);
    tree.insert(30);
    tree.insert(15);
    tree.insert(25);

    std::cout << "Inorder traversal of the tree: ";
    tree.printInorder();
    std::cout << std::endl;

    return 0;
}

//输出结果：Inorder traversal of the tree: 10 15 20 25 30 

先让gpt回答吧
怎么说呢，说到红黑树，必然先从avl 平衡二叉树讲起

而且红黑树在unordered_map、redis、等数据存储用很多应用

平衡性维护方式：

AVL树：通过保持任意节点的左子树和右子树的高度差不超过1来维护平衡。在插入或删除节点时，可能需要进行旋转操作来保持平衡。
红黑树：通过一系列的旋转和重新着色操作来维护平衡。红黑树不追求严格的平衡，但它保证了树的黑高度是O(log n)，从而保证了树的高度近似平衡。
旋转次数：

AVL树：由于 AVL 树要求严格的平衡，插入或删除操作可能需要进行更多的旋转操作来保持平衡，因此在某些情况下，AVL树的旋转次数会比红黑树多。
红黑树：红黑树的平衡性维护更加宽松，旋转和重新着色的次数相对较少，因此在实践中通常比 AVL 树更高效。
性能特点：

AVL树：由于 AVL 树严格追求平衡，因此在查找操作上可能比红黑树更快，因为 AVL 树的高度更低。但是在插入和删除操作上可能更耗时，因为可能需要进行更多的旋转操作。
红黑树：红黑树在插入和删除操作上的性能通常比 AVL 树更好，因为它的平衡性维护更加宽松，旋转和重新着色的次数较少。红黑树在实际应用中更为广泛，例如在C++的STL中就使用了红黑树来实现map和set等容器。
总的来说，AVL树和红黑树都是自平衡的二叉查找树，它们各有优缺点，在不同的应用场景中选择合适的数据结构是很重要的。

关联容器的实现：红黑树常被用作关联容器的底层实现，例如C++ STL中的std::map和std::set就是基于红黑树实现的。这些容器可以快速地进行查找、插入和删除操作，并且保持元素的有序性。

数据库索引：数据库系统中经常需要快速地查找和更新数据，红黑树作为一种高效的数据结构，常被用作数据库索引的底层实现。它可以支持快速的数据检索操作，并且保持索引的平衡性。

操作系统内核：红黑树在操作系统内核中也有广泛的应用，用于实现各种数据结构和算法。例如，在Linux内核中，红黑树被用于进程调度、文件系统、内存管理等方面。

路由表：计算机网络中的路由器常使用红黑树来存储路由表，以支持快速的路由查找和更新。红黑树可以高效地存储和管理大量的网络路由信息，并且保持路由表的平衡性。

内存分配器：在动态内存分配器中，红黑树可以用于管理内存分配和释放的元数据，以支持快速的内存分配和释放操作，并且保持内存分配器的高效性和平衡性。

总的来说，红黑树作为一种高效的自平衡二叉查找树，具有广泛的应用领域，可以在各种场景中提供高效的数据存储和检索功能。