红黑树

下面网址中是红黑树很好的教材，很详细。

http://blog.csdn.net/eric491179912/article/details/6179908

另外经典教材就是算法导论中关于红黑树的章节了，以算法导论为主，实在不明白的地方再去网上查找资料。

红黑树是一种特殊的二叉查找树，大家都知道二叉查找树的复杂度最坏情况为O(h)，为了减低最坏情况的复杂度，大神们设计了许多种二叉查找树的改进版本，红黑树便是其中之一，它可以保证在最坏情况下复杂度为O(lgn)，也就是说h < lgn。

红黑树的五个性质

1）每个节点或者是红色，或者是黑色

2）根节点是黑色

3）每个叶子节点是黑色的(此处的叶子节点指的是外部节点)

4）红色节点的两个孩子都是黑色的

5）对于每个节点，从该节点到其子孙叶子节点的所有路径上包含相同数目的黑色节点

红黑树节点的定义

typedef struct node
{
	int color;
	int key;
	struct node *p;//指向父节点
	struct node *left, *right;

}RBtreeNode;

与二叉搜索树相比较，多出了2部分，本节点的颜色属性和指向父节点是指针，之所以需要指向父节点是为了后序操作的便利。

红黑树的左旋和右旋

在节点x上左旋，是以x和x的右孩子y之间的轴为支点，旋转结束后x成为y的左孩子；在节点y上右旋，是以y和y的左孩子x之间的轴为支点，旋转结束后y是x的右孩子；如图所示

   ，理论上与二叉搜索树的旋转没有任何区别

红黑树的插入

假设新插入节点z，我们将其置为红色，可能破坏性质2）和性质4），违反性质2）是因为新插入的点成为了根节点，违反性质4）是因为z->p也是红色；插入z后，从底向上逐层调整树的结构和颜色，使其仍然满足红黑树的性质。既然从底层开始调整，我们可以只考虑违反性质4），当然在调整过程中绝不允许出现违反其他性质的现象。

前提z的父亲是红色

case1--z的叔叔是红色

z的叔叔uncle_z是红色，那z的爷爷肯定是黑色，可以把z的父亲和叔叔置为黑色，z的爷爷置为红色，z <- z的爷爷，然后继续向上操作。

case2--uncle_z是黑色，且z和uncle_z不是同一方向的孩子，即z是左孩子，uncle_z是右孩子；或者z是右孩子，uncle_z是左孩子

　　case2.1--z是左孩子，uncle_z是右孩子，如下面左图所示。我们以z的爷爷为输入，做一次右旋操作，同时把parent_z置为黑色，gparent_z置为红色，整棵树调整结束。

     左右分割   

　　case2.2--z是右孩子，uncle_z是左孩子，如上面右图所示。我们，以z的爷爷为输入，做一次左旋操作，同时把parent_z置为黑色，gparent_z置为红色，整棵树调整结束。

 可以看到，case2.1和case2.2是对称的两种情况。

case3--uncle_z是黑色，且z和uncle_z是同一方向的孩子，即z是左孩子，uncle_z也是左孩子；或者z是右孩子，uncle_z也是右孩子

 　　case3.1--z和uncle_z同时是左孩子，如下面左图所示。我们以z的父亲为输入，做一次右旋操作，同时把z置为旋转前z的父亲，变成了case2.2，有木有！！

  左右分割  

　　case3.2--z和uncle_z同时是右孩子，如上面右图所示。我们以z的父亲为输入，做一次左旋操作，同时把z置为旋转前z的父亲，变成了case2.1。

插入的最后，在把root的颜色置为黑色，完事。

 红黑树的删除

假设被删除节点是z，可以找到真正要被删除的节点y，即如果z至多有一个孩子，y等于z；否则y是z的中序后继，此时y至多有一个右孩子；总的说来y至多只有一个右孩子x。如果y是红色，删除y后仍然能够保证红黑树的5个性质；如果y是黑色，可能违反性质2），4），5）。删除y时就是把x代替了y的位置，我们可以给x额外增加一个黑色，使其成为了双黑色和红黑色，这样满足了性质5），但违反性质1）。

如果x是红黑色，我们将其置为黑色，调整结束；

如果x是根节点，我们将其置为黑色，结束；

如果x是双黑色，做必要的旋转和涂色。

假设parent_x为删除节点y后x的父节点，实际上就是y的父节点，那么parent_x一定是有两个孩子的，因为此时y非空，且y是黑色，在不违反性质5）的前提下，y一定有兄弟。令parent_x的另一个孩子为w，即x的兄弟为w

case1--w为黑色，且w的两个孩子都是黑色

因为w是黑色，x是双重黑色，可以同时去掉x和w的黑色，x的父节点增加一重黑色，不会违反性质5），然后把x赋值给x的父节点，继续循环。如下面两幅图所示

    左右分割  

 case2--w是黑色，且w同一方向的孩子是红色，即若w是左孩子，w的左孩子是红色；若w是右孩子，w的右孩子是红色。我们可以通过旋转使x的高度减一，并且在x和x的父亲之间增加一个黑色节点，最后把x置为根节点，循环结束

　　case2.1--w是黑色，w是左孩子，w的左孩子是红色，以w的父节点为输入，做一次左旋，并且做一些颜色涂改

   左右分割   

 　　case2.2--w是黑色，w是右孩子，w的右孩子是红色，以w的父节点为输入，做一次右旋，并且做一些颜色涂改

 case3--w是黑色，w同一方向的孩子是黑色，我们可以通过旋转使其转化为case2

　　case3.1--w是黑色，w是左孩子，w的左孩子是黑色，那么右孩子一定是红色，否则就成了case1;以w为输入，做一次右旋，变成了case2.1

    左右分割  

　　case3.2--w是黑色，w是右孩子，w的右孩子是黑色，那么左孩子一定是红色，否则就成了case1;以w为输入，做一次左旋，变成了case2.2

  case4--w是红色的，则w肯定有黑孩子，parent_x是黑色的，以parent_x为输入，做一次左旋，可转变成case1,case2,或者case3

 

 附源代码，另附测试数据的大神博客网址：http://blog.csdn.net/v_JULY_v/article/details/6284050

//红黑树基本操作
#include <stdio.h>
#include <list>

#define BLACK 0
#define RED 1
typedef struct node
{
	int color;
	int key;
	struct node *p;
	struct node *left, *right;

}treeNode;

//在节点x上左旋操作，以x和x右孩子之间的轴为支点，旋转结束后x成为y的左孩子
//      x                  y
//     / \   left_rotate  / \ 
//    lx  y     --->     x  ry
//       / \            / \
//      ly ry          lx ly
treeNode* left_rotate(treeNode* root, treeNode* x)
{
	treeNode *y = x->right;
	x->right = y->left;
	if(y->left != NULL)
		(y->left)->p = x;
	y->p = x->p;
	if(x->p == NULL)//x是根节点
		root = y;
	else if(x == (x->p)->left)
		(x->p)->left = y;
	else (x->p)->right = y;
	y->left = x;
	x->p = y;

	return root;
}

//在节点y上的右旋操作，以y和y的左孩子x之间的轴为支点，旋转结束后y是x的右孩子
//      y                  x
//     / \  right_rotate  / \ 
//    x  ry     --->     lx  y
//   / \                    / \          
//  lx rx                  rx ry
treeNode* right_rotate(treeNode* root, treeNode* y)
{
	treeNode *x = y->left;
	y->left = x->right;
	if(x->right != NULL)
		(x->right)->p = y;
	x->p = y->p;
	if(y->p == NULL)//y是根节点
		root = x;
	else if(y == (y->p)->left)
		(y->p)->left = x;
	else (y->p)->right = x;
	x->right = y;
	y->p = x;
	return root;
}

//插入新的节点后必须得调整
treeNode* rb_insert_fixup(treeNode *root, treeNode *z)
{
	treeNode *uncle_z;
	while(z->p && z->p->color == RED && z->p->p)
	{
		if (z->p->p->left == z->p)//z的父亲是左孩子
		{
			uncle_z = z->p->p->right;//z的叔父是右孩子
			//case1--叔父是右孩子，红色
			if(uncle_z && uncle_z->color == RED)
			{
				uncle_z->color = BLACK;
				z->p->color = BLACK;
				z->p->p->color = RED;
				z = z->p->p;
			}
			//case1 end
			else
			{	
				//case2--叔父是右孩子，黑色 z是右孩子
				if (z == z->p->right)//如果z是右孩子
				{
					z = z->p;
					root = left_rotate(root, z);
				}
				//case2 end 
				//case3--叔父是右孩子，黑色 z是左孩子
				z->p->color = BLACK;
				z->p->p->color = RED;
				root = right_rotate(root, z->p->p);
				//case3 end
			}
		}
		else//z的父亲是右孩子
		{
			uncle_z = z->p->p->left;//z的叔父是左孩子
			//case4--叔父是左孩子，红色
			if (uncle_z && uncle_z->color == RED)
			{
				uncle_z->color = BLACK;
				z->p->color = BLACK;
				z->p->p->color = RED;
				z = z->p->p;
			}
			//case4 end
			else 
			{	
				//case5--叔父是左孩子，黑色，z是左孩子
				if (z == z->p->left)
				{
					z = z->p;
					root = right_rotate(root, z);
				}
				//case5 end
				//case6--叔父是左孩子，黑色 z是右孩子
				z->p->color = BLACK;
				z->p->p->color = RED;
				root = left_rotate(root, z->p->p);
				//case6 end
			}
		}
	}
	root->color = BLACK;
	return root;
}

//插入新的节点
treeNode* rb_insert(treeNode *root, int value)
{
	treeNode *z = new treeNode;
	z->key = value;
	treeNode *x = root;
	treeNode *y = NULL;

	while(x != NULL)
	{
		y = x;
		if(value == x->key)
			return root;
		if(value < x->key)
			x = x->left;
		else x = x->right;
	}
	z->p = y;
	if (y == NULL)
	{
		root = z;
	}
	else
	{
		if(value < y->key)
			y->left = z;
		else
			y->right = z;
	}
	z->left = NULL;
	z->right = NULL;
	z->color = RED;
	root = rb_insert_fixup(root, z);
	return root;
}
//删除节点x的父节点后调整, x相当于多重黑色或者红黑色
treeNode* rb_delete_fixup(treeNode *root, treeNode *x, treeNode *parent_x)
{
	treeNode *w;//x_brother
	while(x!=root && (x == NULL ||x->color == BLACK))
	{
		//x的父亲parent_x一定有两个孩子
		if(x == parent_x->left)
		{
			w = parent_x->right;//x的右兄弟w
			//case1--x的兄弟w为红色，则w肯定有黑孩子,左旋,转换成case2,case3....
			if(w->color == RED)
			{
				w->color = BLACK;
				parent_x->color = RED;
				root = left_rotate(root, parent_x);
				w = parent_x->right; //w重新置为parent_x的右孩子
			}
			//case1 end
			//case2--w为黑色，w的两个孩子(如果有)也是黑色
			if((w->left == NULL || w->left->color == BLACK) && (w->right == NULL || w->right->color == BLACK))
			{
				w->color = RED;
				x = parent_x;
				parent_x = parent_x->p;
			}
			//case2 end	
			else
			{	//case3--w的右孩子是黑色，左孩子是红色
				if(w->right == NULL || w->right->color == BLACK)
				{
					if(w->left != NULL)//如果w有左孩子,一定是红色
						w->left->color = BLACK;
					w->color = RED;
					root = right_rotate(root, w);
					w = parent_x->right;
				}
				//case3 end
				//case4 w的右孩子是红色
				if (w->right != NULL)//如果w有右孩子，一定是红色
					w->right->color = BLACK;
				w->color = parent_x->color;
				parent_x->color = BLACK;	
				root = left_rotate(root, parent_x);
				x = root;
			}
		}
		else//与上面对称
		{
			w = parent_x->left;//x的左兄弟w
			//case5--x的兄弟w为红色，则w肯定有黑孩子,右旋,转换成case2,case3....
			if(w->color == RED)
			{
				w->color = BLACK;
				parent_x->color = RED;
				root = right_rotate(root, parent_x);
				w = parent_x->left;
			}
			//case5 end
			//case6--w为黑色，w的两个孩子(如果有)也是黑色
			if((w->left == NULL || w->left->color == BLACK) && (w->right == NULL || w->right->color == BLACK))
			{
				w->color = RED;
				x = parent_x;
				parent_x = parent_x->p;
			}
			//case6 end
			else
			{
			//case7--w的左孩子是黑色，右孩子是红色
				if(w->left == NULL || w->left->color == BLACK)
				{
					if(w->right != NULL)
						w->right->color = BLACK;
					w->color = RED;
					root = left_rotate(root, w);
					w = parent_x->left;
				}
				//case7 end
				//case8 w的左孩子是红色
				if (w->left->color == RED)
					w->left->color = BLACK;
				w->color = parent_x->color;
				parent_x->color = BLACK;	
				root = right_rotate(root, parent_x);
				x = root;
				//case8 end
			}
		}
	}

	if(x != NULL)
		x->color = BLACK;
	return root;
}

treeNode* rb_delete(treeNode *root, int value)
{
	treeNode *z, *y, *x;
	z = root;
	while(z != NULL)
	{
		if(z->key == value)
			break;
		if(z->key < value)
			z = z->right;
		else
			z = z->left;
	}
	if(z == NULL) //木有找到要删除的节点
		return root;
	y = z;
	if(y->left!=NULL && y->right!=NULL)//两个孩子的情况，y是z的中序后继
	{
		y = y->right;
		while (y->left != NULL)
		{
			y = y->left;
		}
		z->key = y->key;
	}
	//x是y唯一的孩子或者NULL
	if(y->left != NULL)
		x = y->left;
	else x = y->right;
	
	if(x)
		x->p = y->p;
	if(y->p == NULL)//y是根节点
		root = x;
	else if(y == y->p->left)
		y->p->left = x;
	else y->p->right = x;
	
	if(y->color==BLACK)
		root = rb_delete_fixup(root, x, y->p);
	delete y;
	return root;
}

treeNode* rb_find(treeNode *root, int value)
{
	treeNode *x = root;
	int h = 0;
	while (x != NULL)
	{
		if (x->key == value)
		{
			if(x->color == RED)
				printf("RED ");
			else
				printf("BLACK ");
			printf("从0层计数，%d在第%d层\n", value, h);
			return x;
		}
		if (x->key < value)
			x = x->right;
		else x = x->left;
		h++;
	}
	return NULL;
}

void midOrder(treeNode *root)
{
	if(root == NULL)
		return;
	midOrder(root->left);
	printf("%d-", root->key);
	if(root->color == RED)
		printf("RED ");
	else
		printf("BLACK ");
	midOrder(root->right);
}

void preOrder(treeNode *root)
{
	if(root == NULL)
		return;
	printf("%d-", root->key);
	if(root->color == RED)
		printf("RED ");
	else
		printf("BLACK ");
	preOrder(root->left);
	preOrder(root->right);
}


int main()
{
	int select, a;
	treeNode *root = NULL;
	do 
	{
		printf("请输入选择 1--插入，2--查询， 3--删除, 4--输出中序和前序，其他跳出\n");
		scanf("%d", &select);
		if (select == 1)
		{
			printf("输入将要插入的值, -1表示结束\n");
			while(scanf("%d", &a), a != -1)
			{
				root = rb_insert(root, a);
			}
		}
		else if (select == 2)
		{
			printf("输入将要查询的值, -1表示退出查询\n");
			while(scanf("%d", &a), a != -1)
			{
				if(rb_find(root, a) != NULL)
				{
					//printf("找到了\n");
				}
				else
					printf("木有找到\n");
			}
		}
		else if(select == 3)
		{
			printf("输入将要删除的值, -1表示退出删除\n");
			while(scanf("%d", &a), a != -1)
			{
				root = rb_delete(root, a);
			}
		}
		else if(select == 4)
		{
			printf("中序是:\n");
			midOrder(root);
			printf("\n前序是:\n");
			preOrder(root);
			printf("\n");
		}
		else break;

	} while (true);
	

	getchar();
	return 0;
}

运行结果，据小雨自己测试没有错误，欢迎大家前来拍砖