测试代码所用的例子为算导第三版p179图13-4
#include <iostream>
using namespace std;
const bool BLACK = 0; // 黑色
const bool RED = 1; // 红色
struct node // 结点结构
{
node *left;
node *right;
node *parent;
int key;
bool color;
node(node *init, int data) : left(init), right(init), parent(init), key(data), color(BLACK) {}
};
class RB_tree
{
public:
node *root; // 指向根结点
node *nil; // 空节点(哨兵)(黑色)
RB_tree(){ nil = new node(nullptr, -1); root = nil; } // 初始化nil结点和root
node *left_rotate(node *x); // 左旋
node *right_rotate(node *x); // 右旋
void RB_insert(node *z); // 插入一个结点
void RB_insert_fixup(node *z); // 插入后调整
node *tree_minimum(node *x); // 找最小值
node *tree_successor(node *x); // 找到x的后继
node *RB_search(node *x, int k); // 查找元素
node *RB_delete(node *z); // 删除一个结点
void RB_delete_fixup(node *x); // 删除后调整
void RB_print(node *x);
void print();// 输出
};
node *RB_tree::left_rotate(node *x) // 先将y的左孩子变为x的右孩子(y有做孩子的话)
{ // 然后让y成为x父节点的右孩子(x为根节点的话 y直接变为根节点)
node *y = x->right; // 最后让x变为y的左孩子
x->right = y->left;
if (y->left != nil)
{
y->left->parent = x;
}
y->parent = x->parent;
if (x->parent == nil)
{
root = y;
}
else if (x->parent->left == x)
{
x->parent->left = y;
}
else
{
x->parent->right = y;
}
y->left = x;
x->parent = y;
return y;
}
node *RB_tree::right_rotate(node *x) // y的右孩子成为x的左孩子 y成为x父亲的孩子 x成为y的右孩子
{
node *y = x->left;
x->left = y->right;
if (y->right != nil)
{
y->right->parent = x;
}
y->parent = x->parent;
if (x->parent == nil)
{
root = y;
}
if (x->parent->right == x)
{
x->parent->right = y;
}
else
{
x->parent->left = y;
}
y->right = x;
x->parent = y;
return y;
}
void RB_tree::RB_insert(node *z)
{
node *y = nil;
node *x = root;
// 利用x不断向下并赋值给y 找到z的插入点
while (x != nil)
{
y = x;
if (z->key < x->key)
{
x = x->left;
}
else
{
x = x->right;
}
}
// 将 z插入到y的合适部位
z->parent = y;
if (y == nil) // 树空的时候 z成为根结点
{
root = z;
}
else if (z->key < y->key)
{
y->left = z;
}
else
{
y->right = z;
}
// 调整先插入的z的属性 然后调整 保持树的性质
z->left = nil;
z->right = nil;
z->color = RED; // 必须为红 黑的话 会破坏树的性质
RB_insert_fixup(z); // 向上调整维护树的性质
}
void RB_tree::RB_insert_fixup(node *z)
{
node *y;
while (z->parent->color == RED)
{
if (z->parent == z->parent->parent->left)
{
y = z->parent->parent->right;
if (y->color == RED) // case 1 z的叔节点是红色的
{
z->parent->color = BLACK;
y->color = BLACK;
z->parent->parent->color = RED;
z = z->parent->parent;
}
else // case 2 z的叔节点黑色且z是右孩子
{
if (z == z->parent->right)
{
z = z->parent;
left_rotate(z);
}
z->parent->color = BLACK; // case 3 z的叔节点是黑色的且z是左孩子
z->parent->parent->color = RED;
right_rotate(z->parent->parent);
}
}
else if (z->parent == z->parent->parent->right) // p[z]为右孩子的时候 与上面对称
{
y = z->parent->parent->left;
if (y->color == RED)
{
z->parent->color = BLACK;
y->color = BLACK;
z->parent->parent->color = RED;
z = z->parent->parent;
}
else
{
if (z == z->parent->left)
{
z = z->parent;
right_rotate(z);
}
z->parent->color = BLACK;
z->parent->parent->color = RED;
left_rotate(z->parent->parent);
}
}
}
root->color = BLACK; // 根结点调整为黑色
}
node *RB_tree::tree_minimum(node *x) // 求最小值
{
while (x->left != nil)
{
x = x->left;
}
return x;
}
node *RB_tree::tree_successor(node *x) // 寻找元素的后继
{
if (x->right != nil) // 右子树不为空的话 在右子树中找到最小值就是
{
return tree_minimum(x->right);
}
node *y = x->parent; // 一直向上寻找
while (y != nil && x == y->right)
{
x = y;
y = y->parent;
}
return y;
}
node *RB_tree::RB_search(node *x, int k) // 寻找某个元素
{
if (x->key == -1 || k == x->key)
{
return x;
}
if (k < x->key)
{
return RB_search(x->left, k);
}
else
{
return RB_search(x->right, k);
}
}
node *RB_tree::RB_delete(node *z) // 删除某个元素 与BST基本一样
{
node *x, *y;
if (z->left == nil || z->right == nil)
y = z;
else
y = tree_successor(z);
if (y->left != nil)
x = y->left;
else
x = y->right;
x->parent = y->parent; // 不需要判断x是否为nil 无条件执行 BST要执行判断
if (y->parent == nil)
{
root = x;
}
else if (y == y->parent->left)
{
y->parent->left = x;
}
else
{
y->parent->right = x;
}
if (y != z)
{
z->key = y->key;
}
if (y->color == BLACK) // 如果删除的是黑色结点 则向上调整树的性质 删除的是红色的什么也不影响 直接删掉即可
{
RB_delete_fixup(x);
}
return y;
}
void RB_tree::RB_delete_fixup(node *x) // 假设删除的y的黑色给了x x有了两层黑色这样可以满足性质5 只需要调整性质1 2 4即可
{
node *w; // x的叔节点
while (x != root && x->color == BLACK) //while循环的目的是将额外的黑色沿树上移(循环内部x时钟指向双重黑色结点)
{ // 直到 1.x指向红黑结点,最后将x着色为(单个)黑
if (x == x->parent->left) // 2.x指向根节点 此时可以简单的移除额外的黑色
{ // 3.执行适当的旋转和重新着色 退出循环
w = x->parent->right;
if (w->color == RED) // case 1
{
w->color = BLACK;
x->parent->color = RED;
left_rotate(x->parent);
w = x->parent->right;
}
if (w->left->color == BLACK && w->right->color == BLACK) // case 2
{
w->color = RED;
x = x->parent;
}
else
{
if (w->right->color == BLACK) // case 3
{
w->left->color = BLACK;
w->color = RED;
right_rotate(w);
w = x->parent->right;
}
w->color = x->parent->color; // case 4
x->parent->color = BLACK;
w->right->color = BLACK;
left_rotate(x->parent);
x = root;
}
}
else if (x == x->parent->right) // x是右孩子的是 与上面对称的过程
{
w = x->parent->left;
if (w->color == RED)
{
w->color = BLACK;
x->parent->color = RED;
right_rotate(x->parent);
w = x->parent->left;
}
if (w->right->color == BLACK && w->left->color == BLACK)
{
w->color = RED;
x = x->parent;
}
else
{
if (w->left->color == BLACK)
{
w->right->color = BLACK;
w->color = RED;
left_rotate(w);
w = x->parent->left;
}
w->color = x->parent->color;
x->parent->color = BLACK;
w->left->color = BLACK;
right_rotate(x->parent);
x = root;
}
}
}
x->color = BLACK; // 目的是把新结点染为单一黑色
}
void RB_tree::RB_print(node *x)
{
if (x->key == -1)
{
return;
}
RB_print(x->left);
cout << x->key << " " << x->color << endl;
RB_print(x->right);
}
void RB_tree::print() // 中序遍历树 全部输出
{
RB_print(root);
cout << endl;
}
int main()
{
RB_tree T;
int s[9] = {7,2,11,1,5,8,14,4,15};
for (int i = 0; i < 9; ++i)
{
node *z = new node(T.nil, s[i]);
T.RB_insert(z);
T.print();
}
cout << (*(T.root)).key << endl;
T.RB_delete(T.root);
cout << endl;
T.print();
return 0;
}