本文深入介绍了红黑树和2-3树的数据结构及其特点。红黑树是一种自平衡二叉搜索树，通过节点颜色约束保证了搜索效率。2-3树则是一种特殊的二叉搜索树，允许节点存储多个键值。在插入和删除操作中，红黑树通过旋转和颜色调整维持平衡。文章详细阐述了插入、删除节点的处理流程，包括左旋、右旋、自平衡调整等操作，以及查找后继节点的方法。这些内容对于理解和实现高效数据结构至关重要。
红黑树和B树
本文章是自己查询资料总结复习使用的，不喜勿喷
2-3树介绍
首先需要明白理解23树对于理解红黑树和B树都是有好处。
- 那么23树是什么？
23树满足二分搜索树的基本性质。- 我们看23树的key的种类。
2-node: one key, two children.一个key值，两个儿子节点
3-node: two keys, three children。两个key值，三个儿子节点
当超过3个node的时候会进行树重构，节点上升。
那么23树的查找怎么做了？
- 比较要查找的key与当前节点中的key值
- 根据key值选择要查找的key所存在的子树区间
- 重复上述步骤（递归实现），直到查找到key
插入的步骤怎么做了？
- 如果是向一个2-node插入节点的话，那么直接将它转换为3-node就可以了
- 如果向3-node插入怎么办了？此时已经达到了节点最大值，无法插入数据了。只能做节点变换，一般直接将中间的节点上移到父节点此时就可以插入数据了。
- 如果不清楚的话先看看上面的PDF中的234树，因为主要讲红黑树
红黑树
什么是红黑树？
红黑树（Red Black Tree）是一种自平衡的二叉搜索树（Self-balancing Binary Search Tree）。以前也叫做平衡二叉 B 树（Symmetric Binary B-tree）。它在每个节点增加了一个存储位记录节点的颜色，可以是RED,也可以是BLACK；通过任意一条从根到叶子简单路径上颜色的约束，红黑树保证最长路径不超过最短路径的二倍，因而近似平衡
平衡二叉搜索树
平衡二叉搜索树（Balanced Binary Search Tree），英文简称 BBST。经典常见的平衡二叉搜索树是 AVL 树和红黑树。
二叉搜索树
二叉搜索树（Binary Search Tree）是二叉树的一种，英文简称 BST。又称为二叉查找树、二叉排序树。
它的特点是任何一个结点的值都大于其左子树的所有结点的值，任何一个结点的值都小于其右子树的所有结点的值
问题：1.有了二叉查找树、平衡树为啥还需要红黑树？
- 平衡树是为了解决二叉查找树退化为链表的情况，
- 红黑树是为了解决平衡树在插入、删除等操作需要频繁调整的情况。(因为因为平衡树要求每个节点的左子树和右子树的高度差至多等于1，这导致需要频繁调用左旋右旋来满足这个条件)
- 红黑树是一种不大严格的平衡树
一棵二叉搜索树平均时间复杂度可以认为是树的高度 O(h)。像左边这棵，结点的左右子树的高度接近，属于一棵平衡二叉搜索树，O(h) = O(logn)；而右边这棵，高度达到了最大，已经退化成了链表，O(h)=O(n)。
AVL树的特点
- 每个结点的平衡因子只可能是 -1、0、1（如果绝对值超过 1，则认为是失衡）
- 每个结点的左右子树高度差不超过 1
- 搜索、插入、删除的时间复杂度是 O(logn)
红黑树定义和性质
- 每个结点是要么是红色或黑色
- 根结点必须是黑色
- 叶结点（外部结点、空结点）是黑色
- 红色结点不能连续（也就是，红色结点的孩子和父亲都是黑色）
- 对于每个结点，从该点至 nil（树尾端，Java 中为 null 的结点）的任何路径都包含所相同个数的黑色结点
结构体定义
#define RED 1
#define BLACK 2
typedef int KEY_TYPE;
typedef struct _rbtree_node {
unsigned char color; //颜色
struct _rbtree_node *right; //左子节点
struct _rbtree_node *left; //右子节点
struct _rbtree_node *parent; //父节点
KEY_TYPE key; //关键字(键值)
void *value; //值
} rbtree_node;
typedef struct _rbtree {
rbtree_node *root; //树根
rbtree_node *nil;
} rbtree;
左旋
/*************对红黑树节点x进行左旋操作 ******************/
/*
* 左旋示意图：对节点x进行左旋
* p p
* / /
* x y
* / \ / \
* lx y -----> x ry
* / \ / \
* ly ry lx ly
* 左旋做了三件事：
* 1. 将y的左子节点赋给x的右子节点,并将x赋给y左子节点的父节点(y左子节点非空时)
* 2. 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右)
* 3. 将y的左子节点设为x，将x的父节点设为y
*/
//左旋转
void rbtree_left_rotate(rbtree *T, rbtree_node *x) {
//1. 将y的左子节点赋给x的右子节点，并将x赋给y左子节点的父节点(y左子节点非空时)
rbtree_node *y = x->right; // x --> y , y --> x, right --> left, left --> right
x->right = y->left;
if (y->left != T->nil) {
y->left->parent = x;
}
//2. 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右)
y->parent = x->parent;
if (x->parent == T->nil) { //如果x的父节点为空，则将y设为父节点
T->root = y;
} else if (x == x->parent->left) {
x->parent->left = y;
} else {
x->parent->right = y;
}
//3. 将y的左子节点设为x，将x的父节点设为y
y->left = x;
x->parent = y;
}
右旋
/*************对红黑树节点y进行右旋操作 ******************/
/*
* 右旋示意图：对节点y进行右旋
* p p
* / /
* y x
* / \ / \
* x ry -----> lx y
* / \ / \
* lx rx rx ry
* 右旋做了三件事：
* 1. 将x的右子节点赋给y的左子节点,并将y赋给x右子节点的父节点(x右子节点非空时)
* 2. 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右)
* 3. 将x的右子节点设为y，将y的父节点设为x
*/
//右旋转
void rbtree_right_rotate(rbtree *T, rbtree_node *y) {
rbtree_node *x = y->left;
//1. 将y的左子节点赋给x的右子节点，并将x赋给y左子节点的父节点(y左子节点非空时)
y->left = x->right;
if (x->right != T->nil) {
x->right->parent = y;
}
//2. 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右)
x->parent = y->parent;
if (y->parent == T->nil) {
T->root = x;
} else if (y == y->parent->right) {
y->parent->right = x;
} else {
y->parent->left = x;
}
//3. 将x的右子节点设为y，将y的父节点设为x
x->right = y;
y->parent = x;
}
插入
void rbtree_insert(rbtree *T, rbtree_node *z) {
rbtree_node *y = T->nil;
rbtree_node *x = T->root; //从根结点开始查找；
//一查找插入的位置 即找到要插入的父节点；
while (x != T->nil) {
y = x;
if (z->key < x->key) {
x = x->left;
} else if (z->key > x->key) {
x = x->right;
} else { //Exist
return ;
}
}
z->parent = y;
if (y == T->nil) { //若根结点为空，那么插入结点作为根结点
T->root = z;
} else if (z->key < y->key) {//若插入节点的key小于当前节点的key，则插到当前节点的左节点
y->left = z;
} else { //否则插入到当前节点的右节点
y->right = z;
}
z->left = T->nil; //将插入节点的左右节点置空，把颜色设置为红色
z->right = T->nil;
z->color = RED; //插入颜色为红色 理由很简单，红色在父结点（如果存在）为黑色结点时，红黑树的黑色平衡没被破坏，不需要做自平衡操作。但如果插入结点是黑色，那么插入位置所在的子树黑色结点总是多1，必须做自平衡。
rbtree_insert_fixup(T, z); //插入后自平衡。
}
插入后的自平衡操作
定义节点的意思：
- N-node：当前结点
- P-parent：父结点
- S-sibling：兄弟结点
- U-uncle：叔父结点（P 的兄弟结点）
- G-grand：祖父结点（P 的父结点）
情况1：
处理：
- 将父结点和叔父结点变为黑色
- 将祖父结点变为红色
- 将祖父结点设置为当前插入结点
//插入修正(进行旋转) 怎么没判断根节点为空的情况
void rbtree_insert_fixup(rbtree *T, rbtree_node *z) {
/*
* while循环在每次迭代的开头都保持3个部分的不变式
* 1 节点z是红色节点
* 2 如果z.p是根节点，则z.p是黑节点
* 3 如果有任何红黑性质被破坏，则至多只有一条被破坏，或是性质2(根为黑色节点)，或是性质4(如果一个节点是红色的，
* 则它的两个子节点都是黑色的)
*/
//这个循环的最终目的使得性质4得到满足，一行中不再有两个红色节点
while (z->parent->color == RED) { //z ---> RED z节点的父节点存在且颜色为红色
if (z->parent == z->parent->parent->left) {//父节点是左节点
rbtree_node *y = z->parent->parent->right;
// Case1:如果它的叔叔节点是红色，则将父节点，叔叔节点的颜色都设置为黑色，祖父节点颜色设置成红色的，让后跳到情况二和三
if (y->color == RED) {
z->parent->color = BLACK;
y->color = BLACK;
z->parent->parent->color = RED;
z = z->parent->parent; //z --> RED
情况2：
处理：
- 将父结点变为黑色
- 将祖父结点变为红色
- 将祖父结点右旋
//Case3:z叔叔节点y是黑色的，但z是左节点
z->parent->color = BLACK; //将z父节点颜色变成黑色，祖父节点的颜色变成红色（将两个节点的颜色互换）
z->parent->parent->color = RED;
rbtree_right_rotate(T, z->parent->parent);//然后对z的祖父节点进行右旋
}
情况3：
处理：
- 将父结点进行左旋
*将父结点设为插入结点，得到场景 4.2.1- 进行场景 4.2.1 的处理
// Case2: z叔叔节点y是黑色的，但z是右节点
if (z == z->parent->right) {
z = z->parent; //将关注节点变成z的父节点
rbtree_left_rotate(T, z); //然后对新z节点进行左旋，然后跳到情况三
}
删除节点
定义节点的意思：
- R：替换结点
- P：替换结点的父结点
- S：替换结点的兄弟结点
- SL：兄弟结点的左子结点
- SR：兄弟结点的右子结点
- 灰色：结点颜色可能是红色，也可能是黑色
注：R 是即将被替换到删除结点的位置的替换结点，在删除前，它还在原来所在位置参与树的子平衡，平衡后再替换到删除结点的位置，才算删除完成。
①场景 1：替换结点为红色
我们把替换结点换到了删除结点的位置时，由于替换结点为红色，删除也了不会影响红黑树的平衡，只要把替换结点的颜色变为删除的结点的颜色即可重新平衡。
处理：替换结点颜色变为删除结点的颜色。
②场景 2：替换结点为黑色
当替换结点是黑色时，就必须进行自平衡处理了，我们可以通过区分替换结点是其父结点的左子结点还是右子结点，来做不同的旋转，使树重新平衡。
/*
*删除结点找替代结点有3种情情景：
* 情景1：若删除结点无子结点，直接删除
* 情景2：若删除结点只有一个子结点，用子结点替换删除结点
* 情景3：若删除结点有两个子结点，用后继结点（大于删除结点的最小结点）替换删除结点
*/
rbtree_node *rbtree_delete(rbtree *T, rbtree_node *z) {
rbtree_node *y = T->nil;
rbtree_node *x = T->nil;
//被删除节点的左右节点都不为空的情况
if ((z->left == T->nil) || (z->right == T->nil)) {
y = z;
} else {
y = rbtree_successor(T, z);//获取到被上传节点的后继节点
}
if (y->left != T->nil) { //如果后继节点的左节点或右节点不为空
x = y->left;
} else if (y->right != T->nil) {
x = y->right;
}
x->parent = y->parent;
if (y->parent == T->nil) {
T->root = x;
} else if (y == y->parent->left) {
y->parent->left = x;
} else {
y->parent->right = x;
}
if (y != z) {
z->key = y->key;
z->value = y->value;
}
if (y->color == BLACK) {//当替换节点是红色的时候，只要把颜色变成删除节点的颜色就平衡了，但是如果是黑色就需要做平衡操作
rbtree_delete_fixup(T, x);
}
return y;
}
查找后继节点
当x =4.5的时候,4是前驱结点，6是后继节点情况1
当x = 5.5 的时候找前驱结点为5，后继节点同理可得
rbtree_node *rbtree_successor(rbtree *T, rbtree_node *x) {//找到该节点的后继节点，即大于x的最小值
rbtree_node *y = x->parent;
if (x->right != T->nil) {//当右子树不为空的时候 情况1
return rbtree_mini(T, x->right);//沿着左边的找到大于x的最小节点
}
//情况2
while ((y != T->nil) && (x == y->right)) {//当没有右子数的时候往回走，直到x是父节点的右节点的时候就是找到后继节点
x = y;
y = y->parent;
}
return y;
}
告诉大家一种找前继和后继结点的直观的方法（不知为何没人提过，大家都知道？）：
- 把二叉树所有结点投射在X轴上，所有结点都是从左到右排好序的，所有目标结点的前后结点就是对应前继和后继结点。
- 在实际的系统中，例如，需要使用动态规则的防火墙系统，使用红黑树而不是散列表被实践证明具有更好的伸缩性。
删除后的自平衡
情况1：
处理：
- 将兄弟结点变为黑色
- 将父结点变为红色
- 对父结点进行左旋，得到场景 2.1.2.3
- 进行场景 2.1.2.3 的处理
void rbtree_delete_fixup(rbtree *T, rbtree_node *x) {
while ((x != T->root) && (x->color == BLACK)) {//while循环中，x总是指向一个具有双重黑色的非根界节点
if (x == x->parent->left) {
rbtree_node *w= x->parent->right;
if (w->color == RED) {//情况1：x的兄弟节点w是红色
w->color = BLACK;
x->parent->color = RED;
rbtree_left_rotate(T, x->parent);
w = x->parent->right;//因为左旋会变化原来w的位置，由叔叔位置变成祖父位置，所以要重新赋值
}
情景2：
处理：
- 如果父结点为黑色：将兄弟结点变为红色；将父结点作为新的替换结点；重新进行删除结点的场景处理。
- 如果父结点为红色：替换结点的父结点和替换结点的兄弟结点颜色交换；删除结点和替换结点的值交换后，删除替换结点。
if ((w->left->color == BLACK) && (w->right->color == BLACK)) { //情况2:x的兄弟节点w是黑色，而且w的两个子节点都是黑色的
w->color = RED;//把兄弟节点的颜色设为红色
x = x->parent;//重新进行删除节点情景处理
情景3
处理：
- 将兄弟结点的左子结点变为黑色
- 将兄弟结点变为红色
- 对兄弟结点进行右旋，得到场景 2.1.2.1(即情况4)
- 进行场景 2.1.2.1 的处理(即情况4)
} else {
if (w->right->color == BLACK) {//情况3：x的兄弟节点w是黑色的，w的左孩子是红色的，w的右孩子是黑色的
w->left->color = BLACK;
w->color = RED;
rbtree_right_rotate(T, w);
w = x->parent->right;
}
//情况4：x的兄弟节点w是黑色的，且w的右孩子是红色的
w->color = x->parent->color;
x->parent->color = BLACK;
w->right->color = BLACK;
rbtree_left_rotate(T, x->parent);
x = T->root;
}
情景4：
处理：
- 将兄弟结点的颜色变为父结点的颜色
- 将父结点变为黑色
- 将兄弟结点的右子结点变为黑色
- 对父结点进行左旋
//情况4：x的兄弟节点w是黑色的，且w的右孩子是红色的
w->color = x->parent->color;
x->parent->color = BLACK;
w->right->color = BLACK;
rbtree_left_rotate(T, x->parent);
x = T->root;
}
替换结点是右子树
} else { //x = x->parent->right
rbtree_node *w = x->parent->left;
if (w->color == RED) {
w->color = BLACK;
x->parent->color = RED;
rbtree_right_rotate(T, x->parent);
w = x->parent->left;
}
if ((w->left->color == BLACK) && (w->right->color == BLACK)) {
w->color = RED;
x = x->parent;
} else {
if (w->left->color == BLACK) {
w->right->color = BLACK;
w->color = RED;
rbtree_left_rotate(T, w);
w = x->parent->left;
}
w->color = x->parent->color;
x->parent->color = BLACK;
w->left->color = BLACK;
rbtree_right_rotate(T, x->parent);
x = T->root;
}
}
}
x->color = BLACK;//x指向的根节点
}
情景1：
处理：
- 将兄弟结点变为黑色
- 将父结点变为红色
- 对父结点进行右旋，得到场景 2.2.2.3
- 进行场景 2.2.2.3 的处理
情景2：
处理：
- 如果父结点为黑色：将兄弟结点变为红色；将父结点作为新的替换结点；重新进行删除结点的场景处理。
- 如果父结点为红色：替换结点的父结点和替换结点的兄弟结点颜色交换；删除结点和替换结点的值交换后，删除替换结点。
情景3：
处理：
- 将兄弟结点的颜色变为父结点的颜色
- 将父结点变为黑色
- 将兄弟结点的右子结点变为黑色
- 对父结点进行右旋
情景4：
处理：
- 将兄弟结点变为红色
- 将兄弟结点的右子结点设为黑色
- 对兄弟结点进行左旋，得到场景 2.2.2.1(即情况3)
- 进行场景 2.2.2.1 的处理(即情况3)
搜索节点
rbtree_node *rbtree_search(rbtree *T, KEY_TYPE key) {
rbtree_node *node = T->root; //从根结点开始查找，把根结点设置为当前结点；
while (node != T->nil) {//若当前结点不为空，用当前结点的key跟查找key作比较；
if (key < node->key) { //若当前结点key大于查找key，把当前结点的左子结点设置为当前结点
node = node->left;
} else if (key > node->key) { //若当前结点key小于查找key，把当前结点的右子结点设置为当前结点
node = node->right;
} else { //若当前结点key等于查找key，那么该key就是查找目标，返回当前结点；
return node;
}
}
return T->nil; //若当前结点为空，返回null；
}
遍历树的每个节点(用递归的方式)
void rbtree_traversal(rbtree *T, rbtree_node *node) {
if (node != T->nil) {
rbtree_traversal(T, node->left);
printf("key:%d, color:%d\n", node->key, node->color);
rbtree_traversal(T, node->right);
}
}
扫一扫
3248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
