红黑树插入和删除的各种情况分析

1.红黑树的定义

红黑树是一种自平衡的二叉查找树，是一种高效的查找树，定义如下：

1. 每个节点是红色或黑色
2. 根是黑色
3. 所有叶子都是黑色（叶子是NIL节点）
4. 如果一个节点是红色的，则他的两个儿子是黑色的（从每个叶子到根的所有路径上不能有两个连续的红色节点）
5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点（简称黑高）

2.红黑树的数据结构

typedef int KEY_TYPE;

//定义红黑树的节点
typedef struct _rbtree_node {
	unsigned char color;
	struct _rbtree_node *right;
	struct _rbtree_node *left;
	struct _rbtree_node *parent;
	KEY_TYPE key;
} rbtree_node;

//定义红黑树整棵树
//root为根节点
//所有的叶子节点指向nil（以前我也觉得没必要，后来发现这样判断叶子节点挺好用的）
typedef struct _rbtree {
	rbtree_node *root;
	rbtree_node *nil;
} rbtree;

3.左旋和右旋分析

左旋步骤：
1）修改X的"右儿子指针"指向b
2）修改b的"父亲指针"指向X
3）修改Y的"父亲指针"指向Z
4）修改Z的"（左或者右）儿子指针"指向Y
5）修改Y的"左儿子指针"指向X
6）修改X的"父亲指针"指向Y
代码如下：（注意：判断b是否为叶子和传入的节点是根节点还是左右节点）

void rbtree_left_rotate(rbtree *T, rbtree_node *x) {
	rbtree_node *y = x->right;  

	x->right = y->left; //1 
	if (y->left != T->nil) { //2
		y->left->parent = x;
	}

	y->parent = x->parent; //3
	if (x->parent == T->nil) { //4
		T->root = y;
	} else if (x == x->parent->left) {
		x->parent->left = y;
	} else {
		x->parent->right = y;
	}

	y->left = x; //5
	x->parent = y; //6
}

右旋步骤：
1）修改Y的"左儿子指针"指向b
2）修改b的"父亲指针"指向Y
3）修改X的"父亲指针"指向Z
4）修改Z的"（左或者右）儿子指针"指向X
5）修改X的"右儿子指针“指向Y
6）修改Y的”父亲指针“指向X
代码如下：（注意：判断b是否为叶子和传入的节点是根节点还是左右节点）

void rbtree_right_rotate(rbtree *T, rbtree_node *y) {

	rbtree_node *x = y->left;

	y->left = x->right;//1
	if (x->right != T->nil) {//2
		x->right->parent = y;
	}

	x->parent = y->parent;//3
	if (y->parent == T->nil) {//4
		T->root = x;
	} else if (y == y->parent->right) {
		y->parent->right = x;
	} else {
		y->parent->left = x;
	}

	x->right = y;//5
	y->parent = x;//6
}

3.插入的情况分析

1）根据要插入的key的值，找到叶子结点并插入。
2）判断当前结点key的父节点是否为黑色，是则退出，否则进入第三步。
3）判断当前结点key叔叔节点是否为红色，是则进去第四步，否则进入第五步。
4）将当前结点key的祖父节点变红，key的父节点和叔叔节点变黑，在将当前结点指向祖父节点并回到第二步。（笔记：因为父亲是红色节点，所以祖父肯定不是红色节点，是黑色节点）
5）判断当前结点key的父亲节点是否为祖父节点的左儿子，是则进入第六步，否则进入第八步。
6）判断当前结点key是否为父亲节点的左儿子，是则进入第七步，否则对当前节点key的父亲节点进行左旋，再进入第七步。（注意：经过左旋后，当前节点上去了，曾经的父亲节点下来了，当前节点key指向的是下来的节点（曾经的父亲节点））
7）将当前结点key的父亲节点变色为黑色，祖父节点变色为红色，最后将当前节点key指向祖父节点，对当前节点key进行右旋，并返回第二步。（笔记：经过右旋后，当前节点肯定是黑色，因为他是曾经的父亲节点旋转上来的）
8）判断当前结点key是否为父亲节点的右儿子，是则进入第七步，否则对当前节点key的父亲节点进行右旋，再进入第九步。（注意：经过右旋后，当前节点上去了，曾经的父亲节点下来了，当前节点key指向的是下来的节点（曾经的父亲节点））
9）将当前结点key的父亲节点变色为黑色，祖父节点变色为红色，最后将当前节点key指向祖父节点，对当前节点key进行左旋，并返回第二步。（笔记：经过左旋后，当前节点肯定是黑色，因为他是曾经的父亲节点旋转上来的）

void rbtree_insert_fixup(rbtree *T, rbtree_node *z) {
	//步骤二
	while (z->parent->color == RED) { 
		//步骤五
		if (z->parent == z->parent->parent->left) {
			rbtree_node *y = z->parent->parent->right;
			//步骤三
			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->right) {//步骤六
					z = z->parent;
					rbtree_left_rotate(T, z);
				}

				z->parent->color = BLACK;
				z->parent->parent->color = RED;
				rbtree_right_rotate(T, z->parent->parent);
			}
		}else {
			rbtree_node *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;
					rbtree_right_rotate(T, z);
				}

				z->parent->color = BLACK;
				z->parent->parent->color = RED;
				rbtree_left_rotate(T, z->parent->parent);
			}
		}
		
	}

	T->root->color = BLACK;
}


void rbtree_insert(rbtree *T, rbtree_node *z) {

	rbtree_node *y = T->nil;
	rbtree_node *x = T->root;
	//步骤一
	while (x != T->nil) {
		y = x;
		if (z->key < x->key) {
			x = x->left;
		} else if (z->key > x->key) {
			x = x->right;
		} else { //Exist
			return ;
		}
	}

	z->parent = y;
	if (y == T->nil) {
		T->root = z;
	} else if (z->key < y->key) {
		y->left = z;
	} else {
		y->right = z;
	}

	z->left = T->nil;
	z->right = T->nil;
	z->color = RED;

	rbtree_insert_fixup(T, z);
}

举个例子
在下面的红黑树中插入4这个节点

步骤一：找到4的位置，并且插进去，颜色为红色，变为下图

步骤二：当前节点（4）的父亲节点（5）是红色的，进入第三步，
步骤三：叔叔节点（8）是红色的，进入第四步，
步骤四：将当前结点key的祖父节点（7）变红，key的父节点（5）和叔叔节（8）点变黑，在将当前结点指向祖父节点（7）并回到第二步，变为下图。

步骤二：当前节点（7）的父亲节点（2）是红色的，进入第三步，
步骤三：叔叔节点（14）是黑色的，进入第五步，
步骤五：当前节点（7）的父亲节点（2）是为祖父节点（11）的左儿子，进入第六步
步骤六：当前节点（7）不是为父亲节点（2）的左儿子，当前节点的父亲节点（2）进行左旋，再进入第七步。（注意：经过左旋后，当前节点变为曾经的父亲节点（2）了）
步骤七：将当前节点（2）的父亲节点（11）变色为黑色，祖父节点（11）变色为红色，最后将当前节点key指向祖父节点，对当前节点key进行右旋，并返回第二步。（笔记：经过右旋后，当前节点肯定是黑色，因为他是曾经的父亲节点旋转上来的），变为下图。

步骤七：将当前节点（2）的父亲节点（7）变色为黑色，祖父节点（11）变色为红色，最后将当前节点指向祖父节点（11），对当前节点key进行右旋，并返回第二步。（笔记：经过右旋后，当前节点肯定是黑色，因为他是曾经的父亲节点（7）旋转上来的），变为下图。

4.删除的情况分析

1）
2）
4）
5）
6）