红黑树的构建以及插入和删除操作（C语言完整）

参照算法导论伪代码。
注释没有很详细，建议先看算法导论或者其他博主的分析搞清楚insert和delete操作的方法。

#include<stdio.h>
#include<stdlib.h>
typedef int type;
typedef enum Color   //定义红黑树结点颜色颜色类型  
{
	red = 0,
	black = 1
}Color;
typedef struct rbtree     //定义红黑树的结构
{
	Color color;
	type key;
	struct rbtree *left;
	struct rbtree *right;
	struct rbtree *parent;

}node, *tree;

node *nil = NULL;                        //创建一个哨兵结点。这里要用哨兵去让空的叶子结点的颜色是black的，参照红黑树的定义

node* create(type key, node *left, node *right, node *parent)                       //创建结点
{
	node *p;
	p = (node*)malloc(sizeof(node));
	p->color = black;                                                        //默认颜色为black
	p->left = left;
	p->right = right;
	p->parent = parent;
	p->key = key;
	/*	printf("创造结点完毕");*/
	return p;

}

void left_rotate(tree &t, node *x)                                 //左旋，这个看图就能理解具体操作
{
	node *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 right_rotate(tree &t, node *x)                   //右旋
{
	node *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;
}


node* search(tree &t, type key)                        //查找元素
{
	node *x = t;
	if (x == nil || x->key == key)
	{

		return t;
	}

	if (key < x->key)
	{
		
		return search(x->left, key);
	}
	else

	{
	
		return search(x->right, key);

	}


}                                                                  //递归查找

void rb_insert_fixup(tree &t, node* z)
{
	node *y;
	while ((z->parent != nil) && (z->parent->color == red))                                //only when z's parent is red there will probably obey the red node has two black nodes
	{
		if (z->parent == z->parent->parent->left)                //z'parent is the left node
		{

			y = z->parent->parent->right;                         //let y be z's uncle node
			if (y->color == red)                                  //parent and uncle and itself are all red
			{
				z->parent->color = black;
				y->color = black;
				z->parent->parent->color = red;
				z = z->parent->parent;                              //let z up to its grandpa
			}
			else
			{
				if (z == z->parent->right)                         // z is a right node
				{
					z = z->parent;
					left_rotate(t, z);

				}
				z->parent->color = black;
				z->parent->parent->color = red;
				right_rotate(t, z->parent->parent);
			}

		}
		else                                                     //z's parent is the right 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 is a left node
				{
					z = z->parent;
					right_rotate(t, z);
				}
				z->parent->color = black;
				z->parent->parent->color = red;
				left_rotate(t, z->parent->parent);
			}
		}

	}

	t->color = black;                                   //始终保持根节点是黑色
}


node* rb_insert(tree &t, node *z)                        //插入操作
{
	if (t == NULL)                                                  //t是空的树
	{
		t = (tree)malloc(sizeof(node));
		nil = (node*)malloc(sizeof(node));                       //初始化哨兵结点
		nil->color = black;          
		t->left = nil;
		t->right = nil;
		t->parent = nil;
		t->key = z->key;
		t->color = black;         
	}

	else
	{
		node *y = nil;
		node *x = t;                             //


		while (x != nil)
		{
			y = x;
			if (z->key < x->key)
				x = x->left;
			else
				x = x->right;

		}
		z->parent = y;
		if (y == nil)
			t = z;                                  
		else
		{
			if (z->key < y->key)
				y->left = z;
			else
				y->right = z;
		}
		z->left = nil;
		z->right = nil;
		z->color = red;                                     //始终保持插入的结点是红色，不符合具体性质了再用fixup调整
		rb_insert_fixup(t, z);
	}
	return t;
}
node* rb_insert_(tree &t, type k)                  
{
	node *z;
	z = create(k, NULL, NULL, NULL);
	return  rb_insert(t, z);
}


node* min(tree &m)                     //最小值
{

	node *n = m;

	if (n == nil)
		return nil;

	while (n->left != nil)
	{
		n = n->left;
	}
	return n;
}

node* successor(node *s)           //后继
{
	node *p;
	if (s->right != nil)             //结点右子树非空
	{
		return  min(s->right);
	}
	else
	{
		 p = s->parent;                //结点是左孩子，后继就是他的父节点
		while (p != nil && p->right == s)
		{                                       //结点是右孩子，向上查找，直到遇到一个有左孩子的父节点，那就是后继
			{
				s = p;
				p = p->parent;
			}
		}
		return p;
	}
	
}



void rb_delete_fixup(tree &t, node *x)
{
	node *w;
	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;
				left_rotate(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;
				right_rotate(t, w);
				w = x->parent->right;
			}
			w->color = x->parent->color;
			x->parent->color = black;
			w->right->color = black;
			left_rotate(t, x->parent);
			x = t;                                        //

		}
		else
		{
			w = x->parent->left;
			if (w->color = red)
			{
				w->color = black;
				x->parent->color = red;
				right_rotate(t, x->parent);
				w = x->parent->left;
			}
			if (w->left->color == black && w->right->color == black)
			{
				w->color = red;
				x = x->parent;
			}
			else if (w->left->color == black)
			{
				w->right->color = black;
				w->color = red;
				left_rotate(t, w);
				w = x->parent->right;
			}
			w->color = x->parent->color;
			x->parent->color = black;
			w->left->color= black;
			right_rotate(t, x->parent);
			x = t;                                            //

		}
	}
	x->color = black;
}

node* rb_delete(tree &t, node *z)
{
node *y, *x;
    node *m=nil;
	node* n = z;
	if (z->left == nil || z->right == nil)
		y = z;
	else
		y = successor(n);                                  //这一行使z的右孩子发生变化
	if (y->left != nil)
		x = y->left;
	else
		x = y->right;
	x->parent = y->parent;
	if (y->parent == nil)
		t = x;                            //
	else
	{
		if (y == y->parent->left)
			y->parent->left = x;
		else
			y->parent->right = x;
	}
	if (y != z)
	{
		z->key = (y->key);
		
	}
	if (y->color == black)
		rb_delete_fixup(t, x);
	return t;
}

node* rb_delete_(tree &t, type k)
{
	node *z;
	z = search(t, k);

	if (z != nil)
	{
		t = rb_delete(t, z);
	}
	else
		printf("无此元素");
	return t;
}


void print_tree(tree &t)                        //中序遍历打印
{
	if (t != nil && t != NULL)
	{
		print_tree(t->left);
		printf("%7d ,   %5d\n ", t->key, t->color);
		print_tree(t->right);
	}
}

int main()
{
	int i;
	tree zz = NULL, mm = NULL, nn = NULL, xx = NULL, yy = NULL;
	type k;
	int a[12] = {3,12,15,17,19,55,20,18,36,48,31,29 };
	printf("\n原来的数字是：----------------------------------------\n");
	for (i = 0; i<12; i++)
	{
		printf("%d  ", a[i]);
		zz = rb_insert_(zz, a[i]);
	}

	printf("\n中序遍历是：-------------------------------------------\n");
	printf("规定：red=0,black=1\n");
	print_tree(zz);
	printf("\n要删除的值是：---------------------------------------");
	scanf_s("%d", &k);
	yy = rb_delete_(zz, k);
	print_tree(yy);
	printf("\n要插入的值是：--------------------------------------");
	scanf_s("%d", &k);
	rb_insert_(zz, k);
	print_tree(zz);
}

过程中遇到的问题：
1.开始不知道有枚举类型，不知道怎么定义color，用了#define结果总是报错
2.开始没有使用哨兵元素，会导致在逐渐插入的过程中，检验父节点，祖父节点或叔叔结点可能碰到空的时候那个NULL是没有颜色的，运行到这里就中断了。所以必须事先定义好哨兵nil。
3.算法导论上的伪代码结构不算清晰，就是if else 那些嵌套写的不太清楚，得理清楚逻辑结构了才能自己写对。
4.导论上的地方省略了结构相似的部分，x == x->parent->left,->right就省略了，看起来不需要动脑子，其实还是容易写错的
5.学习方式应该是有问题的，先看的算法导论，把思路理得清楚一些了，然后看的网上的解析更明白一些了，但是还是体现在被动的去看懂。然后再去根据导论的伪代码实现，结果又很多bug，改了一些，然后又找了红黑树的现成代码参照修改，把它改出来了。但是这样学习感觉还是很被动的再接受，从翻译伪代码到debug，其实进步并不大，现在要自己不参照伪代码写出来还是不行。甚至不看书复述红黑树的基本思想也不能完整想出来。所以这样是有很多问题的，今后要改进。。。