算法导论 第十三章：红黑树

红黑树（red-black tree）是一种“平衡”查找树，它能保证最坏情况下，基本的动态集操作时间为O(lgn).

性质：

1)每个节点要么是红的，要么是黑的

2)根节点和叶子节点（NIL）是黑色的

3)若一个节点是红色的，则他的两个孩子节点是黑色的

4)对于每一个节点x，从该节点到其子酸节点的所有路径上包含相同数目的黑节点（#black nodes = black-height(x)）

引理：

    一棵有n个内节点的红黑树的高度至多为 2 lg(n+1)

红黑树上插入删除的完整代码如下：

#include<iostream>
#include<iomanip>
using namespace std;

#define BLACK 0
#define RED 1

typedef struct RBTNode{
	int key;
	bool color;
	RBTNode *parent;
	RBTNode *left;
	RBTNode *right;
	}RBTNode;

typedef struct RBTree{
	RBTNode *root;
	}RBTree;

RBTNode NILL={-1,BLACK,NULL,NULL,NULL};
RBTNode *NIL=&NILL;          //init sentinel NIL

void RBT_InorderWalk(RBTNode *x)
{
	if(x!=NIL)
	{
		RBT_InorderWalk(x->left);
		cout<<setw(3)<<x->key;
		if(x->color==1)
			cout<<"     Red"<<endl;
		else
			cout<<"     Black"<<endl;
		RBT_InorderWalk(x->right);
 		}
	}
RBTNode *RBT_Search(RBTNode *x,int key)
{
	if(x->key == key || x==NIL)
		return x;
	if(key < x->key)
		RBT_Search(x->left,key);
	else
		RBT_Search(x->right,key);
		}
RBTNode *RBT_Minimum(RBTNode *x)
{
	while(x->left != NIL)
		x=x->left;
	return x;
	
	}
void Left_Rotate(RBTree *T,RBTNode *x)
{
	RBTNode *y=x->right;    //set y

	x->right=y->left;       //turn y's left subtree into x's right subtree
	if(y->left!=NIL)
		y->left->parent=x;

	y->parent=x->parent;     //link x's parent to y;
	if(x->parent == NIL)
		T->root=y;
	else if(x==x->parent->left)
		x->parent->left=y;
	else
		x->parent->right=y;

	y->left=x;               //put x on y's left
	x->parent=y;
	}

void Right_Rotate(RBTree *T,RBTNode *x)
{
	RBTNode *y=x->left;      //set y
	
	x->left=y->right;   //link x's left tree into y's right subtree;
	if(y->right !=NIL)
		y->right->parent=x;
	
	y->parent=x->parent;    //link x's parent to y
	if(x->parent == NIL)
		T->root=y;
	else if(x == x->parent->left)
		x->parent->left=y;
	else
		x->parent->right=y;
	
	y->right=x;         //put x on y's right
	x->parent=y;

	}
void RBT_InsertFixup(RBTree *T,RBTNode *z)
{
	while(z->parent->color==RED)
	{
		if(z->parent == z->parent->parent->left)    
		{
			RBTNode *y=z->parent->parent->right;   
			if(y->color==RED)
			{  
				z->parent->color=BLACK;            //case 1
				y->color=BLACK;                    //case 1
				z->parent->parent->color=RED;      //case 1
				z=z->parent->parent;               //case 1
				}
			else
			{
			   	if(z==z->parent->right)
				{ 
					z=z->parent;                    //case 2
					Left_Rotate(T,z);               //case 2
				 	}
				z->parent->color=BLACK;             //case 3
				z->parent->parent->color=RED;       //case 3
				Right_Rotate(T,z->parent->parent);  //case 3
		 		} 
		 	}
		else
		{//ame as then clause with "right" and "left" exchanged  
			RBTNode *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(T,z);
				 	}
				z->parent->color=BLACK;
				z->parent->parent->color=RED;
				Left_Rotate(T,z->parent->parent);
			 	} 
			} 
		} 
	T->root->color=BLACK;      //turn the root to BLACK
	}
void RBT_Insert(RBTree *T,int value)
{
	RBTNode *z=new RBTNode();
	z->key=value;
	z->color =RED;   
	z->parent=NIL;
	z->left=NIL;
	z->right=NIL;

	RBTNode *y=NIL;        //y is the parent of x
	RBTNode *x=T->root;
	while(x != NIL)
	{
		y=x;
		if(z->key < x->key)
			x=x->left;
		else
			x=x->right;
		}  
	z->parent=y;   //link new node's parent node to y(y's child is NIL)
	if(y==NIL)
		T->root=z;
	else if(z->key < y->key)
		y->left=z;
	else
		y->right =z;
	RBT_InsertFixup(T,z);
	}

void RBT_Transplant(RBTree *T,RBTNode *u,RBTNode *v)
{
	if(u->parent==NIL)
		T->root=v;
	else if(u==u->parent->left)
		u->parent->left=v;
	else
		u->parent->right=v;
	v->parent=u->parent;
	}
void RBT_DeleteFixup(RBTree *T,RBTNode *x)
{
	RBTNode *w;
	while(x!=T->root && x->color==BLACK)
	{
		if(x==x->parent->left)
	 	{
			w=x->parent->right;  //set w to x's sibling
			if(w->color==RED)      //case 1:x's sibling w is red
			{
				w->color=BLACK;
				x->parent->color=RED;
				Left_Rotate(T,x->parent);
				w=x->parent->right;
	 			}
			if(w->left->color==BLACK && w->right->color==BLACK)  
			{ //case 2:x's sibling w is black and both of w's children are black
				w->color=RED;
				x=x->parent;
				}
			else
			{ 
				if(w->right->color==BLACK)     
				{//case 3:x's sibling w is black,w's left child is red, and w's right child is black
					w->left->color=BLACK;
					w->color=RED;
					Right_Rotate(T,w);
					w=x->parent->right;
			 		}
				w->color=x->parent->color;      //case 4: x's sibling w is black,and w's right child is red
				x->parent->color=BLACK;         //.
				w->right->color=BLACK;         // .
				Left_Rotate(T,x->parent);      // .
				x=T->root;                     //case 4
				}
			}
		else
		{//Same as then clause with "right" and "left" exchanged
			w=x->parent->left;
			if(w->color==RED)
			{
				w->color=BLACK;
				x->parent->color=RED;
				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;
					Left_Rotate(T,w);
					w=x->parent->left;
			 	 	}
				w->color=x->parent->color;
				x->parent->color=BLACK;
				w->left->color=BLACK;
				Right_Rotate(T,x->parent);
				x=T->root;
	 			} 
	 		}
  		}
 	x->color=BLACK;
	}
/*RBTNode *RBT_Successor(RBTNode *x){
     RBTNode *r = x;
     if(r->right != NIL)
         return RBT_Minimum(r->right);
     RBTNode *y = r->parent;
     while(y != NIL && r  == y->right){
         r = y;
         y = y->parent;
     }
     return y;
 }*/
void RBT_Delete(RBTree *T,RBTNode *z)
{
	RBTNode *x=NULL,*y=NULL;
	bool y_origin_color;

	y=z;
	y_origin_color=y->color;
	if(z->left == NIL)
	{
		x=z->right;
		RBT_Transplant(T,z,z->right);
	 	}
	else if(z->right ==NIL)
	{ 
		x=z->left;
		RBT_Transplant(T,z,z->left);
	  	}
	else
	{ 
		y=RBT_Minimum(z->right);
		y_origin_color=y->color;
		x=y->right;

		if(y->parent==z)
			x->parent=y;
		else
		{
			RBT_Transplant(T,y,y->right);
			y->right=z->right;
			y->right->parent=y;
	 		}
		RBT_Transplant(T,z,y);
		y->left=z->left;
		y->left->parent=y;
		y->color=z->color;
	  	}
	if(y_origin_color==BLACK)
		RBT_DeleteFixup(T,x);
		}

int main()
{
	int A[]={41,38,31,12,19,8};
	int n=sizeof(A)/sizeof(int);
	
	cout<<"/*--------------------Ceate Red-Black tree------------------*/"<<endl;
	RBTree *T=new RBTree();
	T->root=NIL;
	for(int i=0;i<n;i++)
		RBT_Insert(T,A[i]);
	cout<<"The Red-Black tree is:"<<endl;
	RBT_InorderWalk(T->root);
	cout<<"The root of the RBT is:"<<T->root->key<<endl;
	cout<<"/*----------------------------------------------------------*/"<<endl;

	cout<<"/*----------------------RBT Insertion-----------------------*/"<<endl;
	int ikey;
	cout<<"Please input the inserting key:";
	cin>>ikey;
	RBT_Insert(T,ikey);
	cout<<"After insertion,the RBT is:"<<endl;
	RBT_InorderWalk(T->root);
	cout<<"The root of the RBT is:"<<T->root->key<<endl;
	cout<<"/*-----------------------------------------------------------*/"<<endl;

	cout<<"/*---------------------RBT Deletion-------------------------*/"<<endl;
	int dkey;
	cout<<"Please input the deleting key:";
	cin>>dkey;
	RBTNode *dNode=NULL;
	dNode=RBT_Search(T->root,dkey);
	if(dNode==NULL)
		cout<<"The deleting key doesn't exist."<<endl;
	else
	{
		RBT_Delete(T,dNode);
		cout<<"After deletion,the RBT is:"<<endl;
		RBT_InorderWalk(T->root);
		cout<<"The root of the RBT is:"<<T->root->key<<endl;
		}

	return 0;
	}

运行结果如下：