红黑树的那些事

红黑树

定义

红黑树是一种自平衡的二叉查找树，它在插入和删除节点时通过变换树的结构来保持树的平衡，从而保证了树的查找、插入和删除操作的时间复杂度都是 O(log n)。

红黑树的节点有两种颜色：红色和黑色。根据红黑树的性质，每个节点要么是黑色，要么是红色。根节点是黑色的，叶子节点（即空节点）是黑色的。如果一个节点是红色的，则它的子节点必须是黑色的。从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑色节点。

红黑树的插入和删除操作都需要通过旋转和变色来保持树的平衡。具体来说，插入操作需要通过旋转和变色来保证插入节点后仍然满足红黑树的性质；删除操作需要通过旋转和变色来保证删除节点后仍然满足红黑树的性质。

红黑树的优点是它的平衡性能比较好，插入、删除和查找操作的时间复杂度都是 O(log n)。缺点是它的实现比较复杂，需要考虑很多情况，容易出错。

使用场景

红黑树适用于需要高效地进行插入、删除和查找操作的场景，尤其是在数据集合比较大、数据分布比较均匀的情况下。

具体来说，红黑树常被用于实现关联数组、集合、映射等数据结构，以及在数据库、操作系统、编译器等领域中的一些算法和数据结构中。

例如，在数据库中，B+树是一种基于红黑树的数据结构，用于实现索引，可以快速地进行数据的查找、插入和删除操作。在操作系统中，红黑树常被用于实现进程调度、内存管理等功能。在编译器中，红黑树常被用于实现符号表、语法树等数据结构。

总之，红黑树适用于需要高效地进行插入、删除和查找操作的场景，尤其是在数据集合比较大、数据分布比较均匀的情况下。

成熟使用场景

1. C++ STL中的std::map和std::set：std::map和std::set都是基于红黑树实现的关联容器，可以快速地进行查找、插入和删除操作。std::map用于实现关联数组，std::set用于实现集合。

2. Linux内核中的进程调度：Linux内核中的进程调度器使用红黑树来维护就绪队列，可以快速地进行进程的调度和切换操作。

3. 数据库中的索引：数据库中的B+树索引常常是基于红黑树实现的，可以快速地进行数据的查找、插入和删除操作。

4. 编译器中的符号表：编译器中的符号表常常是基于红黑树实现的，可以快速地进行符号的查找、插入和删除操作。

5. 操作系统中的内存管理：操作系统中的内存管理器使用红黑树来维护空闲内存块的列表，可以快速地进行内存的分配和释放操作。

总之，红黑树是一种非常实用的数据结构，可以在很多领域中发挥重要作用。

红黑树与B+树的关联性和区别

关联性

B+树是基于红黑树的一种数据结构。B+树是一种多路搜索树，它的每个节点可以存储多个关键字和对应的数据指针，而且所有关键字都按照顺序存储在叶子节点中。B+树的非叶子节点只存储关键字，不存储数据指针，这样可以使得B+树的高度更低，从而提高查询效率。而B+树的叶子节点之间通过指针连接起来，形成一个有序的链表，这样可以方便地进行范围查询和遍历操作。B+树的插入、删除和查找操作都是基于红黑树的算法实现的。

区别

B+树和红黑树都是常用的自平衡树，它们的主要区别在于应用场景和内部结构。

B+树是一种多路搜索树，它的每个节点可以存储多个关键字和对应的数据指针，而且所有的关键字都存储在叶子节点上。B+树的内部结构比较简单，每个节点只需要存储指向子节点的指针和关键字即可。B+树的叶子节点之间通过指针连接成一个有序链表，可以快速地进行范围查询和遍历操作。B+树常被用于实现数据库的索引，可以快速地进行数据的查找、插入和删除操作。

红黑树是一种二叉搜索树，它的每个节点只存储一个关键字和对应的数据指针。红黑树的内部结构比较复杂，每个节点需要存储指向左右子节点的指针、颜色信息和关键字等信息。红黑树的叶子节点是空节点，不存储任何数据。红黑树的平衡性能比B+树更好，可以快速地进行数据的查找、插入和删除操作。红黑树常被用于实现集合、映射等数据结构，以及在操作系统、编译器等领域中的一些算法和数据结构中。

综上所述，B+树适用于需要进行范围查询和遍历操作的场景，例如数据库的索引；而红黑树适用于需要高效地进行插入、删除和查找操作的场景，例如集合、映射等数据结构。

C语言实现RB Tree

#include <stdio.h>
#include <stdlib.h>

// 定义红黑树节点结构体
typedef struct rb_node {
    int key;  // 关键字
    int color;  // 颜色，0表示黑色，1表示红色
    struct rb_node *left;  // 左子节点
    struct rb_node *right;  // 右子节点
    struct rb_node *parent;  // 父节点
} rb_node;

// 定义红黑树结构体
typedef struct rb_tree {
    rb_node *root;  // 根节点
} rb_tree;

// 初始化红黑树
void rb_init(rb_tree *tree) {
    tree->root = NULL;
}

// 创建红黑树节点
rb_node *rb_create_node(int key) {
    rb_node *node = (rb_node *)malloc(sizeof(rb_node));
    node->key = key;
    node->color = 1;  // 新节点默认为红色
    node->left = NULL;
    node->right = NULL;
    node->parent = NULL;
    return node;
}

// 左旋操作
void rb_left_rotate(rb_tree *tree, rb_node *node) {
    rb_node *right = node->right;
    node->right = right->left;
    if (right->left != NULL) {
        right->left->parent = node;
    }
    right->parent = node->parent;
    if (node->parent == NULL) {
        tree->root = right;
    } else if (node == node->parent->left) {
        node->parent->left = right;
    } else {
        node->parent->right = right;
    }
    right->left = node;
    node->parent = right;
}

// 右旋操作
void rb_right_rotate(rb_tree *tree, rb_node *node) {
    rb_node *left = node->left;
    node->left = left->right;
    if (left->right != NULL) {
        left->right->parent = node;
    }
    left->parent = node->parent;
    if (node->parent == NULL) {
        tree->root = left;
    } else if (node == node->parent->left) {
        node->parent->left = left;
    } else {
        node->parent->right = left;
    }
    left->right = node;
    node->parent = left;
}

// 插入节点
void rb_insert(rb_tree *tree, rb_node *node) {
    rb_node *parent = NULL;
    rb_node *current = tree->root;
    while (current != NULL) {
        parent = current;
        if (node->key < current->key) {
            current = current->left;
        } else {
            current = current->right;
        }
    }
    node->parent = parent;
    if (parent == NULL) {
        tree->root = node;
    } else if (node->key < parent->key) {
        parent->left = node;
    } else {
        parent->right = node;
    }
    node->left = NULL;
    node->right = NULL;
    node->color = 1;  // 新节点默认为红色
    while (node != tree->root && node->parent->color == 1) {
        if (node->parent == node->parent->parent->left) {
            rb_node *uncle = node->parent->parent->right;
            if (uncle != NULL && uncle->color == 1) {
                node->parent->color = 0;
                uncle->color = 0;
                node->parent->parent->color = 1;
                node = node->parent->parent;
            } else {
                if (node == node->parent->right) {
                    node = node->parent;
                    rb_left_rotate(tree, node);
                }
                node->parent->color = 0;
                node->parent->parent->color = 1;
                rb_right_rotate(tree, node->parent->parent);
            }
        } else {
            rb_node *uncle = node->parent->parent->left;
            if (uncle != NULL && uncle->color == 1) {
                node->parent->color = 0;
                uncle->color = 0;
                node->parent->parent->color = 1;
                node = node->parent->parent;
            } else {
                if (node == node->parent->left) {
                    node = node->parent;
                    rb_right_rotate(tree, node);
                }
                node->parent->color = 0;
                node->parent->parent->color = 1;
                rb_left_rotate(tree, node->parent->parent);
            }
        }
    }
    tree->root->color = 0;  // 根节点为黑色
}

// 中序遍历红黑树
void rb_inorder_traversal(rb_node *node) {
    if (node != NULL) {
        rb_inorder_traversal(node->left);
        printf("%d ", node->key);
        rb_inorder_traversal(node->right);
    }
}

int main() {
    rb_tree tree;
    rb_init(&tree);
    rb_insert(&tree, rb_create_node(10));
    rb_insert(&tree, rb_create_node(20));
    rb_insert(&tree, rb_create_node(30));
    rb_insert(&tree, rb_create_node(15));
    rb_insert(&tree, rb_create_node(25));
    rb_insert(&tree, rb_create_node(35));
    rb_inorder_traversal(tree.root);  // 输出：10 15 20 25 30 35
    return 0;
}