算法导论之红黑树

红黑树定义：是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是红色也可以是黑色。通过对任意一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长2倍，因而是近似于平衡的。

红黑树的性质：

1.每个节点或者是红色的，或者是黑色的。

2.根结点是黑色的。

3.每个叶子结点都是黑色的。

4.如果一个结点的颜色是红色的，则它的两个子结点都是黑色的。

5.对每个结点，从该结点到其他所有后代叶结点的简单路径上，均包含相同数目的黑色结点。

C语言实现代码如下：

#include <stdio.h>

struct RedBlackNode{
int value;
char color;
struct RedBlackNode *right;
struct RedBlackNode *left;
struct RedBlackNode *parent;
};

typedef struct RedBlackNode RBNode;
//定义全局变量当做叶子结点
RBNode *nil;
//左旋转
RBNode *LEFT_ROTATE(RBNode *root,RBNode *x){
RBNode *y=x->right;
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==x->parent->left){
x->parent->left=y;
}else{
x->parent->right=y;
}
y->left=x;
x->parent=y;
return root;
}
//右旋转
RBNode *RIGHT_ROTATE(RBNode *root,RBNode *x){
RBNode *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;
}else if(x==x->parent->right){
x->parent->right=y;
}else{
x->parent->left=y;
}
y->right=x;
x->parent=y;
return root;
}

//用树v代替树u
RBNode *RB_TRANSPLANT(RBNode *root,RBNode *u,RBNode *v){
if(u->parent==nil){
root=v;
}else if(u==u->parent->left){
u->parent->left=v;
}else{
u->parent->right=v;
}
v->parent=u->parent;
return root;
}
//查找结点z下的最小值的结点
RBNode *TREE_MINIMUM(RBNode *z){
RBNode *rs=z;
while(rs->left!=nil){
rs=rs->left;
}
return rs;
}
//删除后对红黑树进行调整
RBNode *RB_DELETE_FIXUP(RBNode *root,RBNode *x){
RBNode *w = nil;
while(x!=root && x->color=='B'){
if(x==x->parent->left){
w = x->parent->right;
if(w->color=='R'){
w->color='B';
x->parent->color='R';
root = LEFT_ROTATE(root,x->parent);
w=x->parent->right;
}
if(w->left->color=='B' && w->right->color=='B'){
w->color='R';
x=x->parent;
}else {
if(w->right->color=='B'){
w->left->color='B';
w->color='R';
root = RIGHT_ROTATE(root,w);
w = x->parent->right;
}
w->color=x->parent->color;
x->parent->color='B';
w->right->color='B';
root = LEFT_ROTATE(root,x->parent);
x = root;
}
}else {
RBNode *w = x->parent->left;
if(w->color=='R'){
w->color='B';
x->parent->color='R';
root = RIGHT_ROTATE(root,x->parent);
w=x->parent->left;
}
if(w->right->color=='B' && w->left->color=='B'){
w->color='R';
x=x->parent;
}else {
if(w->left->color=='B'){
w->right->color='B';
w->color='R';
root = LEFT_ROTATE(root,w);
w = x->parent->left;
}
w->color=x->parent->color;
x->parent->color='B';
w->left->color='B';
root = RIGHT_ROTATE(root,x->parent);
x = root;
}
}
}
x->color='B';
return root;
}
//删除红黑树中某一结点
RBNode *RB_DELETE(RBNode *root,RBNode *z){
RBNode *y=z;
RBNode *x=nil;
char Y_ORIGINAL_COLOR=y->color;
if(z->left==nil){
x = z->right;
root=RB_TRANSPLANT(root,z,z->right);
}else if(z->right==nil){
x = z->left;
root = RB_TRANSPLANT(root,z,z->left);
}else{
y=TREE_MINIMUM(z->right);
Y_ORIGINAL_COLOR=y->color;
x=y->right;
if(y->parent==z){
x->parent=y;
}else{
root = RB_TRANSPLANT(root,y,y->right);
y->right=z->right;
y->right->parent=y;
}
root = RB_TRANSPLANT(root,z,y);
y->left=z->left;
y->left->parent=y;
y->color=z->color;
}
if(Y_ORIGINAL_COLOR=='B'){
root = RB_DELETE_FIXUP(root,x);
}
return root;
}
//插入某结点后的调整
RBNode *RB_INSERT_FIXUP(RBNode *root,RBNode *z){
while(z->parent->color=='R'){
if(z->parent==z->parent->parent->left){
RBNode *y=z->parent->parent->right;
if(y->color=='R'){
z->parent->color='B';
y->color='B';
z->parent->parent->color='R';
z=z->parent->parent;
}else{
if(z==z->parent->right){
z=z->parent;
root = LEFT_ROTATE(root,z);
}
z->parent->color='B';
z->parent->parent->color='R';
root = RIGHT_ROTATE(root,z->parent->parent);
}
}else {
RBNode *y=z->parent->parent->left;
if(y->color=='R'){
z->parent->color='B';
y->color='B';
z->parent->parent->color='R';
z=z->parent->parent;
}else{
if(z==z->parent->left){
z=z->parent;
root = RIGHT_ROTATE(root,z);
}
z->parent->color='B';
z->parent->parent->color='R';
root = LEFT_ROTATE(root,z->parent->parent);
}
}
}
root->color='B';
return root;
}
//插入一个节点
RBNode *RB_INSERT(RBNode *root,RBNode *z){
RBNode *x=root,*y=nil;
while(x!=nil){
y=x;
if(z->value<x->value){
x=x->left;
}else{
x=x->right;
}
}
z->parent=y;
if(y==nil){
root=z;
}else if(z->value<y->value){
y->left=z;
}else{
y->right=z;
}
z->left=nil;
z->right=nil;
z->color='R';
root = RB_INSERT_FIXUP(root,z);
return root;
}
//中序遍历树
void inOrder(RBNode *tree) {
if (tree != nil) {
inOrder(tree->left);
printf("%d,%c\n",tree->value,tree->color);
inOrder(tree->right);
}
}
//选择一个节点
RBNode *selectNode(RBNode *root,int key){
RBNode *temp = root;
while (temp!=nil) {
if (temp->value >key) {
temp=temp->left;
}else if (temp->value<key) {
temp=temp->right;
}else {
return temp;
}
}
return temp;
}
int main(int argc, char *argv[])
{
nil=(RBNode *)malloc(sizeof(RBNode));
nil->color='B';
RBNode *root = nil;
int a[] = { 41, 38, 31, 12, 19, 8 };
int i = 0,n=sizeof(a)/sizeof(int);
for (; i < n; i++) {
RBNode *z = (RBNode *)malloc(sizeof(RBNode));
z->value = a[i];
root = RB_INSERT(root, z);
}
inOrder(root);

printf("\n测试删除根节点：\n");
RBNode *deleteNode = selectNode(root,38);
root = RB_DELETE(root,deleteNode);
inOrder(root);
return 0;
}
Java语言实现代码如下：
package algorithms;

public class RB_Tree {
public rb_node T = null;
private static String RED = "red";
private static String BLACK = "black";
private static rb_node T_nil = new rb_node(BLACK);

public static class rb_node {
String color;
int key;
rb_node left;
rb_node right;
rb_node p;

public rb_node() {
this.color = RED;
this.key = Integer.MIN_VALUE;
this.left = T_nil;
this.right = T_nil;
this.p = T_nil;
}

public rb_node(String color) {
this.color = color;
this.key = Integer.MIN_VALUE;
this.left = null;
this.right = null;
this.p = null;
}
}

private static rb_node LEFT_ROTATE(rb_node T, rb_node x) {
rb_node y = x.right;
x.right = y.left;
if (y.left != T_nil) {
y.left.p = x;
}
y.p = x.p;
if (x.p == T_nil) {
T = y;
} else if (x == x.p.left) {
x.p.left = y;
} else {
x.p.right = y;
}
y.left = x;
x.p = y;
return T;
}

private static rb_node RIGHT_ROTATE(rb_node T, rb_node x) {
rb_node y = x.left;
x.left = y.right;
if (y.right != T_nil) {
y.right.p = x;
}
y.p = x.p;
if (x.p == T_nil) {
T = y;
} else if (x == x.p.left) {
x.p.left = y;
} else {
x.p.right = y;
}
y.right = x;
x.p = y;
return T;
}

public rb_node RB_INSERT(rb_node T, rb_node z) {
rb_node y = T_nil;
rb_node x = T;
while (x != T_nil) {
y = x;
if (z.key < x.key) {
x = x.left;
} else {
x = x.right;
}
}
z.p = y;
if (y == T_nil) {
T = z;
} else if (z.key < y.key) {
y.left = z;
} else {
y.right = z;
}
z.color = RED;
T = RB_INSERT_FIXUP(T, z);
return T;
}

private static rb_node RB_INSERT_FIXUP(rb_node T, rb_node z) {
while (z.p.color == RED) {
if (z.p == z.p.p.left) {
rb_node y = z.p.p.right;
if (y.color == RED) {
z.p.color = BLACK;
y.color = BLACK;
z.p.p.color = RED;
z = z.p.p;
} else {
if (z == z.p.right) {
z = z.p;
T = LEFT_ROTATE(T, z);
}
z.p.color = BLACK;
z.p.p.color = RED;
T = RIGHT_ROTATE(T, z.p.p);
}
} else {
rb_node y = z.p.p.left;
if (y.color == RED) {
z.p.color = BLACK;
y.color = BLACK;
z.p.p.color = RED;
z = z.p.p;
} else {
if (z == z.p.left) {
z = z.p;
T = RIGHT_ROTATE(T, z);
}
z.p.color = BLACK;
z.p.p.color = RED;
T = LEFT_ROTATE(T, z.p.p);
}
}

}
T.color = BLACK;
return T;
}

public rb_node RB_DELETE(rb_node T, rb_node z) {
rb_node y = z, x;
String y_original_color = y.color;
if (z.left == T_nil) {
x = z.right;
T = RB_TRANSPLANT(T, z, z.right);
} else if (z.right == T_nil) {
x = z.left;
T = RB_TRANSPLANT(T, z, z.left);
} else {
y = TREE_MINIMUM(z.right);
y_original_color = y.color;
x = y.right;
if (y.p == z) {
x.p = y;
} else {
T = RB_TRANSPLANT(T, y, y.right);
y.right = z.right;
y.right.p = y;
}
T = RB_TRANSPLANT(T, z, y);
y.left = z.left;
y.left.p = y;
y.color = z.color;
}
if (y_original_color == BLACK) {
T = RB_DELETE_FIXUP(T, x);
}
return T;
}

private static rb_node RB_DELETE_FIXUP(rb_node T, rb_node x) {
rb_node w = T_nil;
while (x != T && x.color == BLACK) {
if (x == x.p.left) {
w = x.p.right;
if (w.color == RED) {
w.color = BLACK;
x.p.color = RED;
T = LEFT_ROTATE(T, x.p);
w = x.p.right;
}
if (w.left.color == BLACK && w.right.color == BLACK) {
w.color = RED;
x = x.p;
} else {
if (w.right.color == BLACK) {
w.left.color = BLACK;
w.color = RED;
T = RIGHT_ROTATE(T, w);
w = x.p.right;
}
x.p.color = BLACK;
w.color = RED;
T = LEFT_ROTATE(T, x.p);
x = T;
}
} else {
w = x.p.left;
if (w.color == RED) {
w.color = BLACK;
x.p.color = RED;
T = RIGHT_ROTATE(T, x.p);
w = x.p.left;
}
if (w.left.color == BLACK && w.right.color == BLACK) {
w.color = RED;
x = x.p;
} else {
if (w.left.color == BLACK) {
w.right.color = BLACK;
w.color = RED;
T = LEFT_ROTATE(T, w);
w = x.p.left;
}
x.p.color = BLACK;
w.color = RED;
T = RIGHT_ROTATE(T, x.p);
x = T;
}
}

}
x.color = BLACK;
return T;
}

private static rb_node TREE_MINIMUM(rb_node z) {
while (z.left != T_nil) {
z = z.left;
}
return z;
}

private static rb_node RB_TRANSPLANT(rb_node T, rb_node u, rb_node v) {
if (u.p == T_nil) {
T = v;
} else if (u == u.p.left) {
u.p.left = v;
} else {
u.p.right = v;
}
v.p = u.p;
return T;
}

public rb_node selectNode(int key) {
rb_node temp = this.T;
while (temp != T_nil) {
if (temp.key > key) {
temp = temp.left;
} else if (temp.key < key) {
temp = temp.right;
} else {
return temp;
}
}
return temp;
}

public RB_Tree() {
T = T_nil;
}

public void preOrder(rb_node tree) {
if (tree != T_nil) {
System.out.print(tree.key + "->" + tree.color + "\t");
preOrder(tree.left);
preOrder(tree.right);
}
}

public void inOrder(rb_node tree) {
if (tree != T_nil) {
inOrder(tree.left);
System.out.print(tree.key + "->" + tree.color + "\t");
inOrder(tree.right);
}
}

public void postOrder(rb_node tree) {
if (tree != T_nil) {
postOrder(tree.left);
postOrder(tree.right);
System.out.print(tree.key + "," + tree.color);
}
}

public static void main(String[] args) {
String pre = "30 10 20 60 40 50 80 70 90 ";
String in = "10 20 30 40 50 60 70 80 90 ";
String post = "20 10 50 40 70 90 80 60 30 ";
RB_Tree RB = new RB_Tree();
// int a[] = { 10, 40, 30, 60, 90, 70, 20, 50, 80 };
int a[] = { 41, 38, 31, 12, 19, 8 };
for (int i = 0; i < a.length; i++) {
rb_node z = new rb_node();
z.key = a[i];
RB.T = RB.RB_INSERT(RB.T, z);
}

RB.inOrder(RB.T);
System.out.println();
// 测试删除数据
rb_node z = RB.selectNode(38);
RB.T = RB.RB_DELETE(RB.T, z);
RB.inOrder(RB.T);
}

}


在以上的两个版本中，都用了一个哨兵来标记叶子结点（即null结点）。

参考资料：

算法导论


备注：

转载请注明出处：http://blog.csdn.net/wsyw126/article/details/51448271

作者：WSYW12