红黑树

红黑树相比普通二叉搜索树确实要“高级”啊，参考各种资料勉强把代码凑出来了，可能还有bug，但是还是没有搞懂，明天继续研究。。。

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

enum rb_tree_color_type
{
	red   = 0,
	black = 1,
};

struct rb_tree_node
{
	enum rb_tree_color_type color;
	int                     data;
	struct rb_tree_node *   parent;
	struct rb_tree_node *   left;
	struct rb_tree_node *   right;
};

struct rb_tree
{
	struct rb_tree_node *root;
};

/* 创建一个结点 */
struct rb_tree_node *rb_tree_node_alloc(int val)
{
	struct rb_tree_node *ret = (struct rb_tree_node *) malloc(sizeof(struct rb_tree_node));
	ret->color               = red;
	ret->data                = val;
	ret->parent              = NULL;
	ret->left                = NULL;
	ret->right               = NULL;
	return ret;
}

/* 销毁一个结点 */
void rb_tree_node_dealloc(struct rb_tree_node *n)
{
	n->parent = NULL;
	n->left   = NULL;
	n->right  = NULL;
	free(n);
}

/* 销毁整棵子树 */
void rb_tree_node_destroy(struct rb_tree_node *n)
{
	if (n->left != NULL)
	{
		rb_tree_node_destroy(n->left);
	}
	if (n->right != NULL)
	{
		rb_tree_node_destroy(n->right);
	}
	rb_tree_node_dealloc(n);
}

/* 返回子树中最小的元素 */
struct rb_tree_node *rb_tree_node_minimum(struct rb_tree_node *n)
{
	while (n->left != NULL)
	{
		n = n->left;
	}
	return n;
}

/* 返回子树中最大的元素 */
struct rb_tree_node *rb_tree_node_maximum(struct rb_tree_node *n)
{
	while (n->right != NULL)
	{
		n = n->right;
	}
	return n;
}

/* 查找结点在中序遍历序列中的前趋 */
struct rb_tree_node *rb_tree_node_predecessor(struct rb_tree_node *n)
{
	struct rb_tree_node *ret;

	if (n->left != NULL)
	{
		ret = rb_tree_node_maximum(n->left);
	}
	else
	{
		ret = n->parent;
		while (ret != NULL && ret->left == n)
		{
			n   = ret;
			ret = ret->parent;
		}
	}
	return ret;
}

/* 查找结点在中序遍历序列中的后继 */
struct rb_tree_node *rb_tree_node_successor(struct rb_tree_node *n)
{
	struct rb_tree_node *ret;

	if (n->right != NULL)
	{
		ret = rb_tree_node_minimum(n->right);
	}
	else
	{
		ret = n->parent;
		while (ret != NULL && ret->right == n)
		{
			n   = ret;
			ret = ret->parent;
		}
	}
	return ret;
}

/* 输出子树的中序遍历序列 */
void rb_tree_node_inorder_traversal(struct rb_tree_node *n)
{
	if (n->left != NULL)
	{
		rb_tree_node_inorder_traversal(n->left);
	}
	printf("%d ", n->data);
	if (n->right != NULL)
	{
		rb_tree_node_inorder_traversal(n->right);
	}
}

/* 左旋转 */
void rb_tree_left_rotate(struct rb_tree *t, struct rb_tree_node *n)
{
	struct rb_tree_node *child = n->right;

	n->right = child->left;
	if (child->left != NULL)
	{
		child->left->parent = n;
	}

	child->parent = n->parent;
	if (n->parent == NULL)
	{
		t->root = child;
	}
	else
	{
		if (n->parent->left == n)
		{
			n->parent->left = child;
		}
		else
		{
			n->parent->right = child;
		}
	}

	child->left = n;
	n->parent   = child;
}

/* 右旋转 */
void rb_tree_right_rotate(struct rb_tree *t, struct rb_tree_node *n)
{
	struct rb_tree_node *child = n->left;

	n->left = child->right;
	if (child->right != NULL)
	{
		child->right->parent = n;
	}

	child->parent = n->parent;
	if (n->parent == NULL)
	{
		t->root = child;
	}
	else
	{
		if (n->parent->left == n)
		{
			n->parent->left = child;
		}
		else
		{
			n->parent->right = child;
		}
	}

	child->right = n;
	n->parent    = child;
}

/* 调整红黑树以保持性质 */
void rb_tree_insert_fixup(struct rb_tree *t, struct rb_tree_node *n)
{
	struct rb_tree_node *parent;
	struct rb_tree_node *gparent;
	struct rb_tree_node *uncle;
	struct rb_tree_node *temp;

	while ((parent = n->parent) != NULL && parent->color == red)
	{
		gparent = parent->parent;
		if (gparent->left == parent)
		{
			uncle = gparent->right;
			if (uncle != NULL && uncle->color == red)
			{
				uncle->color   = black;
				parent->color  = black;
				gparent->color = red;
				n              = gparent;
			}
			else
			{
				if (parent->right == n)
				{
					temp   = n;
					n      = parent;
					parent = temp;
					rb_tree_left_rotate(t, n);
				}
				parent->color  = black;
				gparent->color = red;
				rb_tree_right_rotate(t, gparent);
			}
		}
		else
		{
			uncle = gparent->left;
			if (uncle != NULL && uncle->color == red)
			{
				uncle->color   = black;
				parent->color  = black;
				gparent->color = red;
				n              = gparent;
			}
			else
			{
				if (parent->left == n)
				{
					temp   = n;
					n      = parent;
					parent = temp;
					rb_tree_right_rotate(t, n);
				}
				parent->color  = black;
				gparent->color = red;
				rb_tree_left_rotate(t, gparent);
			}
		}
	}
	t->root->color = black;
}

/* 插入 */
void rb_tree_insert(struct rb_tree *t, int val)
{
	struct rb_tree_node *parent = NULL;
	struct rb_tree_node *child  = t->root;

	/* 查找应该插入的位置parent */
	while (child != NULL)
	{
		parent = child;
		if (val < child->data)
		{
			child = child->left;
		}
		else
		{
			child = child->right;
		}
	}

	child = rb_tree_node_alloc(val);
	/* 如果parent == NULL说明为空树 */
	if (parent == NULL)
	{
		t->root = child;
	}
	else
	{
		child->parent = parent;
		if (val < parent->data)
		{
			parent->left = child;
		}
		else
		{
			parent->right = child;
		}
	}

	rb_tree_insert_fixup(t, child);
}

/* 调整红黑树以保持性质 */
void rb_tree_erase_fixup(struct rb_tree *t, struct rb_tree_node *n)
{
	struct rb_tree_node *parent;
	struct rb_tree_node *brother;

	while ((n != NULL && n->color == black) && t->root != n)
	{
		parent = n->parent;
		if (parent->left == n)
		{
			brother = parent->right;
			if (brother->color == red)
			{
				brother->color = black;
				parent->color  = red;
				rb_tree_left_rotate(t, parent);
				brother = parent->right;
			}
			if ((brother->left  != NULL && brother->left->color  == black) &&
				(brother->right != NULL && brother->right->color == black))
			{
				brother->color = red;
				n              = n->parent;
			}
			else
			{
				if (brother->right != NULL && brother->right->color == black)
				{
					if (brother->left != NULL)
					{
						brother->left->color = black;
					}
					brother->color = red;
					rb_tree_right_rotate(t, brother);
					brother = parent->right;
				}

				brother->color = parent->color;
				parent->color  = black;
				if (brother->right != NULL)
				{
					brother->right->color = black;
				}
				rb_tree_left_rotate(t, parent);
				n = t->root;
			}
		}
		else
		{
			brother = parent->left;
			if (brother->color == red)
			{
				brother->color = black;
				parent->color  = red;
				rb_tree_right_rotate(t, parent);
				brother = parent->left;
			}
			if ((brother->left  != NULL && brother->left->color  == black) &&
				(brother->right != NULL && brother->right->color == black))
			{
				brother->color = red;
				n              = n->parent;
			}
			else
			{
				if (brother->left != NULL && brother->left->color == black)
				{
					if (brother->right != NULL)
					{
						brother->right->color = black;
					}
					brother->color = red;
					rb_tree_left_rotate(t, brother);
					brother = parent->left;
				}

				brother->color = parent->color;
				parent->color  = black;
				if (brother->left != NULL)
				{
					brother->left->color = black;
				}
				rb_tree_left_rotate(t, parent);
				n = t->root;
			}
		}
	}

	if (n != NULL)
	{
		n->color = black;
	}
}

/* 删除 */
void rb_tree_erase(struct rb_tree *t, struct rb_tree_node *n)
{
	struct rb_tree_node *del;
	struct rb_tree_node *child;

	if (n == NULL)
	{
		return;
	}

	/* 查找应该删除的结点del，del最多只有一个子结点 */
	if (n->left == NULL || n->right == NULL)
	{
		del = n;
	}
	else
	{
		del = rb_tree_node_successor(n);
		/* 若待删除的结点不为n，将待删除结点的数据赋给n */
		n->data = del->data;
	}

	/* 调整子节点的父结点指针 */
	if (del->left != NULL)
	{
		child = del->left;
	}
	else
	{
		child = del->right;
	}
	if (child != NULL)
	{
		child->parent = del->parent;
	}

	/* 若父结点为NULL，说明待删除的结点为树的根结点，此时需要重新调整树的根结点 */
	if (del->parent == NULL)
	{
		t->root = child;
	}
	/* 调整父结点的子结点指针 */
	else if (del->parent->left == del)
	{
		del->parent->left = child;
	}
	else
	{
		del->parent->right = child;
	}

	/* 销毁结点 */
	rb_tree_node_dealloc(del);

	if (del->color == black)
	{
		rb_tree_erase_fixup(t, child);
	}
}

/* 查找，深度优先遍历 */
struct rb_tree_node *rb_tree_search(struct rb_tree *t, int val)
{
	struct rb_tree_node *ret = t->root;

	while (ret != NULL)
	{
		if (val == ret->data)
		{
			break;
		}
		else if (val < ret->data)
		{
			ret = ret->left;
		}
		else
		{
			ret = ret->right;
		}
	}
	return ret;
}

/* 树结构初始化 */
void rb_tree_init(struct rb_tree *t)
{
	t->root = NULL;
}

/* 销毁整棵树 */
void rb_tree_destroy(struct rb_tree *t)
{
	if (t->root != NULL)
	{
		rb_tree_node_destroy(t->root);
		t->root = NULL;
	}
}

/* 输出树的中序遍历序列 */
void rb_tree_inorder_traversal(struct rb_tree *t)
{
	if (t->root != NULL)
	{
		rb_tree_node_inorder_traversal(t->root);
		printf("\n");
	}
}

int main(void)
{
	struct rb_tree t;
	struct rb_tree_node *n;

	rb_tree_init(&t);

	rb_tree_insert(&t, 1);
	rb_tree_insert(&t, 2);
	rb_tree_insert(&t, 3);
	rb_tree_insert(&t, 4);
	rb_tree_insert(&t, 5);
	rb_tree_inorder_traversal(&t);

	n = rb_tree_search(&t, 1);
	rb_tree_erase(&t, n);
	rb_tree_inorder_traversal(&t);
	n = rb_tree_search(&t, 3);
	rb_tree_erase(&t, n);
	rb_tree_inorder_traversal(&t);
	n = rb_tree_search(&t, 4);
	rb_tree_erase(&t, n);
	rb_tree_inorder_traversal(&t);
	n = rb_tree_search(&t, 2);
	rb_tree_erase(&t, n);
	rb_tree_inorder_traversal(&t);
	n = rb_tree_search(&t, 5);
	rb_tree_erase(&t, n);
	rb_tree_inorder_traversal(&t);

	rb_tree_destroy(&t);

	return 0;
}