[算法导论]红黑树

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


using namespace std;
enum Color{RED, BLACK};
const int Length = 10;


typedef struct RB
{
	int key;
	RB *parent;
	RB *left;
	RB *right;
	Color color;
}RBTreeNode, *RBTree;


RBTree NIL = NULL;


void RBInsertFix(RBTree &T, RBTree node);
void LeftRotate(RBTree &T, RBTree x);
void RightRotate(RBTree &T, RBTree x);
void RBInsert(RBTree &T, int num);
void RBTransPlant(RBTree &T, RBTree u, RBTree v);
void RBDeleteFix(RBTree &T, RBTree x);
void RBDelete(RBTree &T, RBTree Node);
void InorderWalk(RBTree T);
RBTree RBTreeMinimum(RBTree T);
void InitRBTree(RBTree &T, int num[]);
RBTree Tree_Search(RBTree T ,int k); //寻找数k是否在树中，且返回数k的地址




int main()
{
	RBTree T;	
	int num[Length] ={12, 2, 34, 56, 26, 8, 31, 6, 20, 3};
	InitRBTree(T, num);
	InorderWalk(T);
	printf("\n\n-----------删除操作后-------------\n");
    
    RBDelete(T,Tree_Search(T,2));
    RBDelete(T,Tree_Search(T,56));
	RBDelete(T,Tree_Search(T,3));
	RBDelete(T,Tree_Search(T,34));
		InorderWalk(T);




}


RBTree Tree_Search(RBTree T ,int k)  //寻找数k是否在树中，且返回数k的地址
{	
	
    while(T !=NIL && T->key != k)
	{
		if ( k < T->key)
			T=T->left;
		else
			T=T->right;
	}
    
	if ( T == NIL)
	{     
		return NULL;
	}
	
	else 
	{
		return T;
	}
	
}


void RightRotate(RBTree &T, RBTree x)
{
	RBTree y = x->left;
	x->left = y->right;
	
	if(y->right != NIL)
		y->right->parent = x;


	y->parent = x->parent;
	if(x->parent == NIL)
	T = y;
	else if(x == x->parent->left)
	x->parent->left = y;
	else
	x->parent->right = y;
	y->right = x;
	x->parent = y;
}
void LeftRotate(RBTree &T, RBTree x)
{
	RBTree y = x->right;
	x->right = y->left;	
	
	if(y->left != NIL)
		y->left->parent = x;
	y->parent = x->parent;
	if(x->parent == NIL)
	T = y;
	else if(x == x->parent->left)
	x->parent->left = y;
	else
	x->parent->right = y;
	y->left = x;
	x->parent = y;
} 


void RBInsert(RBTree &T, RBTree node)
{
	RBTree y = NIL;
	RBTree x = T;
	while(x != NIL)
	{
		y = x;
		if(x->key > node->key)
		x = x->left;
		else
		x = x->right;
	}
	node->parent = y;
	if(y == NIL)
	T = node;
	else if(node->key < y->key)
	y->left = node;
	else
	y->right = node;
	RBInsertFix(T, node);
}


void RBInsertFix(RBTree &T, RBTree node)
{
	RBTree y = NULL;
	while(node->parent->color == RED)
	{
		if(node->parent == node->parent->parent->left)
		{
			y = node->parent->parent->right;
			if(y->color == RED)
			{
				node->parent->color = BLACK;
				y->color = BLACK;
				node->parent->parent->color = RED;
				node = node->parent->parent;
	 		} 
	 		else if(node == node->parent->right)
	 		{
	 			node = node->parent;
	 			LeftRotate(T, node);
				node->parent->color = BLACK;
				node->parent->parent->color = RED;
				RightRotate(T, node->parent->parent);
		 	}	 	
			else
			{
				node->parent->color = BLACK;
				node->parent->parent->color = RED;
				RightRotate(T, node->parent->parent);
			}
	    }
		else
		{
			y = node->parent->parent->left;
			if(y->color == RED)
			{
				node->parent->color = BLACK;
				y->color = BLACK;
				node->parent->parent->color = RED;
				node = node->parent->parent;
	 		} 
	 		else if(node == node->parent->left)
	 		{	
	 			node = node->parent;
	 			RightRotate(T, node); 
				node->parent->color = BLACK;
		 		node->parent->parent->color = RED;
		 		LeftRotate(T, node->parent->parent);
		 	}	
			else
			{
				node->parent->color = BLACK;
				node->parent->parent->color = RED;
				LeftRotate(T, node->parent->parent);
			}
		} 
	}
	T->color = BLACK;
}


void InitRBTree(RBTree &T, int num[])
{
	RBTree node = NULL;
	NIL = (RBTree)malloc(sizeof(RBTreeNode));
	NIL->left = NIL->right = NIL->parent = NULL;
	NIL->color = BLACK;
	T = NIL;
	
	for(int i = 0; i < Length; i++)
	{
		node = (RBTree)malloc(sizeof(RBTreeNode));
		node->left = node->right = node->parent = NIL;
		node->key = num[i];
		node->color = RED;
		RBInsert(T, node);
	}
}


void RBDeleteFix(RBTree &T, RBTree x)
{
	RBTree w = NULL;
	while(x != T && x->color == BLACK)
	{
		if(x == x->parent->left)
		{
			w = x->parent->right;
			if(w->color == RED)
			{
				w->color = BLACK;
				x->parent->color = RED;
				LeftRotate(T, x->parent);
				w = x->parent->right;
			}
			if(w->left->color == BLACK && w->right->color == BLACK)
			{
				w->color = RED;
				x = x->parent;
			}
			else if(w->right->color == BLACK)
			{
				w->left->color = BLACK;
				w->color = RED;
				RightRotate(T, w);
				w = x->parent->right; 
				w->color = x->parent->color;
			x->parent->color = BLACK;
			w->right->color = BLACK;
			LeftRotate(T, x->parent);
			x = T;
			}
		else
		{
				w->color = x->parent->color;
			x->parent->color = BLACK;
			w->right->color = BLACK;
			LeftRotate(T, x->parent);
			x = T;
		}
		}
		else
		{
			w = x->parent->left;
			if(w->color == RED)
			{
				w->color = BLACK;
				x->parent->color = RED;
				RightRotate(T, 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;
				LeftRotate(T, w);
				w = x->parent->left; 
				w->color = x->parent->color;
			x->parent->color = BLACK;
			w->left->color = BLACK;
			RightRotate(T, x->parent);
			x = T;
			}
			else
			{
				w->color = x->parent->color;
			x->parent->color = BLACK;
			w->left->color = BLACK;
			RightRotate(T, x->parent);
			x = T;
			 } 
			
		}
	}
	x->color = BLACK;
 } 
 
void RBTransPlant(RBTree &T, RBTree u, RBTree v)
{
	if(u->parent == NIL)
	T = v;
	else if(u == u->parent->left)
	u->parent->left = v;
	else
	u->parent->right = v;
	
	v->parent = u->parent;//对v无条件执行 即使v是代表空的哨兵NIL 与二叉排序树的不同 
}


/*如果删除的结点y是红色的，则删除后的树仍然是保持红黑树的性质，因为树中各个结点的黑高度没有改变，
不存在两个相邻（父结点和子结点）的红色结点，y是红色不可能是根，所有根仍然是黑色。如果删除的结点z是黑色的，
则这个是破坏了红黑树的性质，需要调用RB_DELETE_FIXUP进行调整。从删除结点y的唯一孩子结点x或者是NIL处开始调整。 
*/


RBTree RBTreeMinimum(RBTree T)
{
	while(T->left != NIL)
	T = T->left;
	return T;
}
void RBDelete(RBTree &T, RBTree Node)
{
	int precolor;
	RBTree y = Node, x = NULL;
	precolor = y->color;//对y也就是z的初始颜色进行记录 
	
	if(Node->left == NIL)
	{
		x = Node->right;//若是z没有左子树 则可以直接将右子树取代z 
		RBTransPlant(T, Node, Node->right);
	}
	else if(Node->right == NIL)
	{
		x = Node->left;//没有右子树 则直接用左子树取代z 
		RBTransPlant(T, Node, Node->left);
	}
	else
	{//存在左右子树 
		y = RBTreeMinimum(Node->right);//找到Node的后继结点 即右子树中的最小值 
		precolor = y->color;//记录y的初始颜色 
		x = y->right;//因为后面的操作会将y变成z原有的颜色 所以违反性质的就是y的右孩子  


		if(y->parent == Node)//如果y是Node的孩子 
		x->parent = y;//x的父节点仍然是y 
		else//作为后继结点的y不是Node的孩子 而存在在其右子树中 
		{//将y 用y的右子树代替 
			RBTransPlant(T, y, y->right);
			y->right = Node->right;
			y->right->parent = y;
		} 
		RBTransPlant(T, Node, y);//将Node 用y代替 
		y->left = Node->left;//将Node的左子树转移到y上 因为y是Node的后继结点因此可以确保大小关系正确 
		y->left->parent = y;
		y->color = Node->color;///更改y的颜色,这样的话从y以上红黑树的性质都不会违反
		
		//若之前的颜色是红色 则不会破坏树的性质 
	
	}	
	if(precolor == BLACK) ///如果y原来的颜色是黑色,那么就意味着有一个黑色结点被覆盖了,
   							///红黑树的性质可能会被破坏(性质4或5),需要调整
		RBDeleteFix(T, x);
} 


void InorderWalk(RBTree T)
{
	if(T == NIL)
	{
		return;
	}
	InorderWalk(T->left);
	printf("%d", T->key);
	if(T->color == BLACK)
	printf("-B  ");
	else
	printf("-R  ");
	InorderWalk(T->right);
}