红黑树

红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求：

性质1. 节点是红色或黑色。

性质2. 根节点是黑色。

性质3. 每个叶节点(NIL节点，空节点)是黑色的。

性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。

要知道为什么这些特性确保了这个结果，注意到性质4导致了路径不能有两个毗连的红色节点就足够了。最短的可能路径都是黑色节点，最长的可能路径有交替的红色和黑色节点。因为根据性质5所有最长的路径都有相同数目的黑色节点，这就表明了没有路径能多于任何其他路径的两倍长。

在很多树数据结构的表示中，一个节点有可能只有一个子节点，而叶子节点不包含数据。用这种范例表示红黑树是可能的，但是这会改变一些属性并使算法复杂。为此，本文中我们使用 “nil 叶子” 或"空(null)叶子"，如上图所示，它不包含数据而只充当树在此结束的指示。这些节点在绘图中经常被省略，导致了这些树好象同上述原则相矛盾，而实际上不是这样。与此有关的结论是所有节点都有两个子节点，尽管其中的一个或两个可能是空叶子。

代码实现

#include "rbtree.h"

#define ISBLACK(node) (node==NULL || node->color==BLACK)


/*
typedef int ETYPE;

enum COL{RED=0,BLACK=1};

typedef struct RBNode
{
	ETYPE elem;
	char color;
	struct RBNode *lchild;
	struct RBNode *rchild;
	struct RBNode *parent;
}RBNode;
typedef struct RBNode * RBTree;
*/ 
static void left(RBTree *proot,RBTree node)
{
	RBTree right=node->rchild;
	right->parent=node->parent;
	if(node->parent!=NULL)
	{
		if(node==node->parent->lchild)
		{
			node->parent->lchild=right;
		}
		else
		{
			node->parent->rchild=right;
		}
	}
	else
	{
		*proot=right; 
	}
	node->rchild=right->lchild;
	if(right->lchild!=NULL)
	{
		right->lchild->parent=node;
	}
	right->lchild=node;
	node->parent=right;
}

static void right(RBTree *proot,RBTree node)
{
	RBTree left=node->lchild;
	left->parent=node->parent;
	if(node->parent!=NULL)
	{
		if(node==node->parent->lchild)
		{
			node->parent->lchild=left;
		}
		else
		{
			node->parent->rchild=left;
		}
	}
	else
	{
		*proot=left; 
	}
	node->lchild=left->rchild;
	if(left->rchild!=NULL)
	{
		left->rchild->parent=node;
	}
	left->rchild=node;
	node->parent=left;
}

static void rb_insert_repair(RBTree *proot,RBTree node)
{
	RBTree parent=node->parent;
	while(node->color==RED && node->parent!=NULL && parent->color==RED)
	{
		RBTree gp=parent->parent;
		RBTree uncle=gp->lchild==parent?gp->rchild:gp->lchild;
		if(uncle!=NULL && uncle->color==RED)
		{
			parent->color=BLACK;
			uncle->color=BLACK;
			gp->color=RED;
			node=gp;
			parent=node->parent;
		}
		else
		{
			if(gp->lchild==parent)
			{
				if(parent->rchild==node)//lr变成ll 
				{
					left(proot,parent);
					node=parent;
					parent=node->parent;
				}
				right(proot,gp);//ll
				gp->color=RED;
				parent->color=BLACK;
			} 
			else
			{
				if(parent->rchild==node)
				{
					right(proot,parent);//rl变成rr 
					node=parent;
					parent=node->parent;
				}
				left(proot,gp);//rr
				gp->color=RED;
				parent->color=BLACK;
			}
			break;
		}
	}
	
	(*proot)->color=BLACK;		
}

static RBTree rb_create_node(int elem,RBTree parent)
{
	RBTree node=malloc(sizeof(RBNode));
	if(node==NULL)
	{
		return NULL;
	}
	node->color=RED;
	node->elem=elem;
	node->lchild=NULL;
	node->rchild=NULL;
	node->parent=parent;
	return node;
}

int rb_insert(RBTree *proot,ETYPE elem)
{	
	RBTree parent=NULL;
	RBTree *ptree=proot;
	while((*ptree)!=NULL)
	{
		parent=*ptree;
		if((*ptree)->elem>elem)
		{
			ptree=&(*ptree)->lchild;	
		}
		else if((*ptree)->elem<elem)
		{
			ptree=&(*ptree)->rchild;
		}
		else
		{
			return -1;	
		}	
	}
	(*ptree)->elem=elem;
	(*ptree)->lchild=NULL;
	(*ptree)->rchild=NULL;
	(*ptree)->parent=parent;
	rb_insert_repair(proot,*ptree);
	return 0;	
}
static void rb_delete_repair(RBTree *proot,RBTree parent,RBTree node)
{
	while(node==NULL && (node==NULL || node->color==BLACK))
	{
		RBTree brother=parent->lchild==node?parent->rchild:parent->lchild;
		if(node==parent->lchild)
		{
			if(brother->color==RED)
			{
				brother->color=BLACK;
				parent->color=RED;
				left(proot,parent);
				brother=parent->rchild; 
			}
			if(ISBLACK(brother) && ISBLACK(brother->lchild) && ISBLACK(brother->rchild))
			{
				if(parent->color==RED)
				{
					parent->color=BLACK;
					brother->color=RED;
					break;
				}
				else
				{
					brother->color=RED;
					node=parent;
					parent=node->parent;
					continue; 
				}
			}
			if(ISBLACK(brother->rchild))
			{
				brother->color=RED;
				brother->lchild->color=BLACK;
				right(proot,brother);
				brother=brother->parent; 
			}
			brother->color=parent->color;
			parent->color=BLACK;
			brother->rchild->color=BLACK;
			left(proot,parent);
			break; 
		}
		else
		{
			if(brother->color==RED)
			{
				parent->color=RED;
				brother->color=BLACK;
				right(proot,parent); 
				brother=parent->lchild;
			}	
			if(ISBLACK(brother) && ISBLACK(brother->lchild) && ISBLACK(brother->rchild))
			{
				if(parent->color==RED)
				{
					parent->color=BLACK;
					brother->color=RED;
					break;
				}
				else
				{
					brother->color=RED;
					node=parent;
					parent=node->parent;
					continue; 
				}
			}
			if(ISBLACK(brother->lchild))
			{
				brother->color=RED;
				brother->rchild->color=BLACK;
				left(proot,brother);
				brother=brother->parent; 
			}
			brother->color=parent->color;
			parent->color=BLACK;
			brother->lchild->color=BLACK;
			right(proot,parent);
			break; 
		} 
	}
}

static void rb_delete_node(RBTree *proot,RBTree *pnode)
{
	RBTree node=*pnode;
	if(node->lchild==NULL && node->rchild==NULL)
	{
		if(node->color==RED)
		{
			*pnode=NULL;
			free(node);
		}
		else
		{
			RBTree parent=node->parent;
			*pnode=NULL;
			free(node);
			rb_delete_repair(proot,parent,NULL);
		}
	} 
	else if(node->lchild!=NULL && node->rchild!=NULL)
	{
		for(pnode=&(*pnode)->lchild;(*pnode)->rchild!=NULL;pnode=&(*pnode)->rchild);
		node->elem=(*pnode)->elem;
		rb_delete_node(proot,pnode);
	}
	else
	{
		*pnode=node->lchild!=NULL?node->lchild:node->rchild;
		(*pnode)->color=BLACK;
		(*pnode)->parent=node->parent; 
		free(node);
	}
}

int rb_delete(RBTree *proot,ETYPE elem)
{
	RBTree *ptree=proot;
	while(*ptree!=NULL)
	{
		if(elem==(*ptree)->elem)
		{
			rb_delete_node(proot,ptree);
			return 0;
		}
		else if(elem<(*ptree)->elem)
		{
			ptree=&(*ptree)->lchild;
		}
		else
		{
			ptree=&(*ptree)->rchild;
		}
	}
	return -1;	
}