补档：红黑树代码实现+简略讲解-优快云博客

本文链接：https://blog.youkuaiyun.com/to_upper/article/details/129127963

本文详细介绍了红黑树的插入和删除操作，包括插入的5种情况和删除的6种情况，以及相应的平衡调整策略，如旋转和颜色调整，确保红黑树的性质得以维持。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

红黑树讲解和实现

1 红黑树介绍
2 完整代码实现
- - 2.1 rtbtree.h头文件
  - 2.2 main.c源文件

1 红黑树介绍

红黑树( Red-Black tree，简称RB树)是一种自平衡二叉查找树，是计算机科学中常见的一种数据结构，其典型用途是实现关联数组。红黑树的结构复杂，但其操作有着良好的最坏情况运行时间，且在实践中有着较高的效率:它可以在O(log2n)时间内完成查找、插入和删除操作，其中的n是树中结点的数量。
红黑树(RB树)是二叉树中重要的知识点，因为在操作系统的内核中、C++的STL和Java的数据结构中都大量使用了红黑树，红黑树的增删查改的复杂度均为log2n。

1.1 红黑树特性

红黑树是每个结点都带有颜色属性的二叉查找树，颜色为红色或黑色，给结点进行染色的原因是用颜色和红黑树性质对树进行平衡，使得红黑树的任意一条路径长度都不可能超过其他路径的两倍。在二叉查找树的–般要求以外，对于任何有效的红黑树，我们额外增加了如下性质：

结点是红色的或黑色的。
根是黑色的。
所有叶子结点都是黑色的(叶子是NIL结点)。
每个红色结点必须有两个黑色的子结点(从每个叶子到根的所有路径上不能有两个连续的红色结点)。
从任意一个点到其每个叶子的所有简单路径都包含相同数量的黑色结点。

王道408考研的咸鱼学长总结了一个口诀：左根右、根叶黑、不红红、黑路同。

1.2 红黑树的插入

红黑树的插入结点，首先标记为红色，按照二叉排序树的方式插入后再做调整。红黑树的插入分为5种情况。
**情形一：**新结点N是树根没有子节点。这种空树的情况，直接将新结点作为根插入染成黑色即可。具体代码如下：

void insert_case1(node *n)
{
	if(n->parent == NULL)//如果新插入结点没有父结点，即此结点为根结点
		n->color = BLACK;//直接染黑
	else 
		insert_case2(n);//否则转入情形2，即有父结点的情况
}

**情形二：**父结点为黑色，则直接将新结点插入，满足性质四不红红（即没有两个连续红色）。还满足性质5，不会增减该路径上黑色结点的数量。具体代码如下：

void insert_case2(node *n)
{
	if(n->parent->color == BLACK)	//如果父结点为黑色，则直接插入
		return;						//不需要调整
	else 
		insert_case3(n);			//如果父结点为红色，则需要调整
}

**情形三：**如果父结点和叔结点都是红色的，那么我们可以将父结点和叔结点都染黑（保证不红红性质4），然后将爷结点染红，插入的子结点仍然是红色（满足路黑同性质5）。此时需要考虑爷结点是否为根结点，如果爷结点为根结点，则需要将爷结点染黑，保证性质不变，如果爷结点不为根结点，则向上将爷结点（红）作为其父结点的新插入结点，递归情形一。下面给出图示和实现代码：
在这里插入图片描述

void insert_case3(node *n)
{
	if(uncle(n)!=NULL && uncle(n)->color == RED && n->parent->color == RED){//这里父结点颜色可以不考虑，否则违反黑路同性质5，为了和算法描述一致，也加入判断
		n->parent->color = BLACK;//将父结点染黑
		uncle(n)->color = BLACK;//将叔结点染黑
		grandparent(n)->color = RED;//将爷结点染红
		insert_case1(grandparent(n));//将红色的爷结点作为新结点，对上级进行调整
	}
	else 
		insert_case4(n);//不满足情形3，则考虑情形4
}

**情形四：**父结点是红色，叔结点是黑色或者缺少的情况，并且新结点是父结点的右子节点，而父结点又是爷结点的左子节点。这种情况需要左旋调换新结点和父结点。
在这里插入图片描述

void insert_case4(node *n)
{
	if(n == n->parent->right && n->parent == grandparent(n)->left){
		roate_left(n->parent);
		n = n->left;
	}
	else if(n->parent->left && n->parent == grandparent(n)->right){
		rotate_right(n->parent);//上图中对称的情况父结点在爷结点右边，子结点在父结点左边
		n = n->right;
	}
	insert_case5(n);//情形5
}

**情形五：**父结点是红色，叔结点是黑色或缺少，子结点是父节点的左子节点，而父结点又是爷结点的左下结点。这种情况需要将爷结点右旋，并且改变相应结点的颜色完成插入。
在这里插入图片描述

void insert_case5(node *n)
{
	n->parent->color = BLACK;
	grandparent(n)->color = RED;
	if(n->parent->left == n && n->parent == grandparent(n)->left){
		rotate_right(grandparent(n));
	}
	else if(n->parent->right == n && n->parent == grandparent(n)->right){
		//与上图中完全对称的情况
		rotate_left(grparent(n);
	}
}

插入修正函数： 对于上述情景3、4、5，红黑树插入结点后，可能会失去平衡，调用此函数保持性质。对于下图中情形三可以单独处理，而情形四可以通过旋转到情形五，进而调整。
在这里插入图片描述

static void rbtree_insert_fixup(RBRoot *root, Node *node)
{
	Node *parent,*gparent;
	//如果父结点存在且为红色需要调整
	while((parent = rb_parent(node)) && rb_is_red(parent)){
		gparent = rb_parent(parent);
		//若父结点是爷结点的左孩子结点
		if(parent == gparent->left){
			//情况1条件：叔结点存在且为红色，这种是情形3
			Node *uncle = gparent->right;
			if(uncle && rb_is_red(uncle)){
				//将父结点和叔结点染黑，将爷结点染红
				rb_set_black(uncle);
				rb_set_black(parent);
				rb_set_red(gparent);
				node = gparent;//node调整完毕，回到父结点
			}
		}
		//情况2条件：叔结点是黑色或不存在，且当前结点是父节点的有孩子，情形4
		//父节点右旋，交换父子结点
		if (parent->right == node){
			Node *tmp;
			rbtree_left_rotate(root, parent);
			tmp = parent;
			parent = node;
			node = tmp;
		}
		//情形3条件：叔结点是黑色，且当前结点是父节点的左孩子结点。这里是情形 5
		rb_set_black(parent); //旋转前设置好颜色
		rb_set_red(gparent); //旋转前设置好颜色
		rbtree_right_rotate(root, gparent);//爷结点右旋
	} 
	else{//若父结点是祖父结点的右孩子结点，则下面三种和上面的是对称的
		Node *uncle = gparent->left;
		if (uncle && rb_is_red(uncle)){
			rb_set_black(uncle);
			rb_set_black(parent);
			rb_set_red(gparent);
			node = gparent;
			continue; //继续进行调整
		}
		if (parent->left == node){
			Node *tmp;
			rbtree_right_rotate(root, parent);
			tmp = parent;
			parent = node;
			node = tmp;
		}
		//Case 3 条件：叔父结点是黑色的，且当前结点是右孩子结点。这里是情形 5
		rb_set_black(parent); //旋转前设置好颜色
		rb_set_red(gparent); //旋转前设置好颜色
		rbtree_left_rotate(root, gparent);
	}
	//将根结点设为黑色
	rb_set_black(root->node);
}

1.3 红黑树的删除

&emps;&emps;对于红黑树的删除中，考虑删除结点为黑色或红色，如果删除结点为红色则不需要做调整，正常删除，因为删除红色结点不会影响黑高。而删除黑色结点则比较复杂，需要考虑以下六种情形。
**注意：**接下来的删除讲解均按照此图进行，此图是指删除结点后红黑树，删除规则按照二叉平衡树的方式，之后未作其他的调整。我们把删除结点N后的替代的结点记为X。
在这里插入图片描述

情形一： 红黑树仅有一个黑根，删除此根满足所有性质。代码如下：

void delete_case1(struct node *n)
{
	if(n->parent!=NULL)
		delete_case2(n);//如果删除的结点不是根
}

情形二： 被删除的黑色结点N，黑色结点X是N的顶替结点，X的兄弟结点W结点是红色。这种删除的情况会使左边黑高-1，破坏了黑路同性质5，所以需要做染色左旋操作。先将父结点染红，再将兄弟结点W染黑，然后对父结点进行左旋操作，这样不会破坏红黑树的性质。
在这里插入图片描述

void delete_case2(struct node *n)
{
	struct node *s = sibling(n);//n的兄弟结点
	if(s->color == RED){//如果兄弟结点是红色
		n->parent->color = RED;//将父结点染红
		s->color = BLACK;//将父结点染黑
		if(n->parent->left == n)//如果n是左孩子
			rotate_ left(n->parent);//父结点左旋 
		else //如果n是右孩子
			rotate_right(n->parent);//父结点右旋
	}
	delete_case3(n);//考虑情景3
	
}

情形三： 被删除的黑色结点N，黑色结点X是N的顶替结点，X的父结点、兄弟结点W及其子结点均为黑色。左侧黑高-1，破坏了黑路同性质5，此时将兄弟结点W染红，使得满足黑路同性质5，但是如果A树作为左子树或者右子树，整体黑高-1，此时需要将矛盾上移，在A结点上重新做平衡处理。代码如下：
在这里插入图片描述

void delete_case3(struct node *n)
{
	struct node *s = sibling(n);
	if((n->parent->color == BLACK) && (S->color == BLACK) && (s->left->color == BLACK) && (s->right->color == BLACK)){
		s->color = RED;//将兄弟结点染红
		delete_case1(n->parent);//将父结点作为新的处理结点，从case1开始平衡
	}
	else 
		delete_case4(n);//如果不符合情形三，请看情形4
}

**情形四：**被删除的黑色结点N，黑色结点X是N的顶替结点，父结点A是红色，兄弟结点W及其子结点都是黑色。此时左侧黑高-1，不满足黑路同性质5，所以需要调整，将父结点A染黑，兄弟结点W染红，则满足性质。代码如下：
在这里插入图片描述

void delete_case4(struct node *n)
{
	struct node *s = sibling(n);
	if((n->parent->color == RED) && (S->color == BLACK) && (s->left->color == BLACK) && (s->right->color == BLACK)){
		s->color = RED;//将兄弟结点染红
		n->parent = BLACK;//将父结点染黑
	}
	else 
		delete_case5(n);//如果不符合情形4，考虑情形五
}

情形五： 被删除的黑色结点N，黑色结点X是N的顶替结点，X的兄弟结点W是黑色，W结点的左子结点是红色，W结点的右子结点是黑色。此时将兄弟结点W染红，W的左子结点染黑，然后进行右旋操作，此时代替结点X和父结点A都不受右旋影响。然后继续情形六。代码如下：
在这里插入图片描述

void
delete_case5(struct node *n)
{
	struct node *s = sibling (n);
	if（s->color == BLACK){
		if((n == n->parent->left)&&(s->right->color == BLACK)&&(s->left->color == RED)) { 
		// 这种情况下 n 结点是其父结点的左子结点，S 结点是其父结点的右子结
			s->color = RED;
			s->left->color = BLACK;
			rotate_right (s);
		} 
		else if((n == n->parent->right)&&(s->left->color == BLACK)&&(s->right->color == RED)) {
		// 这种情况下 n 结点是其父结点的右子结点，S 结点是其父结点的左子结点
			s->color = RED;
			s->right->color = BLACK;
			rotate_left (s);
		}
	}
	delete_case6 (n); //调整完毕后，再通过情形 6 进行调整
}

情形六： 被删除的黑色结点N，黑色结点X是N的顶替结点，兄弟结点W结点是黑色的，W结点的右子结点是红色的，而替代结点X是其父结点A的左子结点。将兄弟结点W染红，将父结点A染黑，W的右子结点也染黑，然后W左旋操作。就达到了情形四的情况。代码如下：
在这里插入图片描述

void delete_case6(struct node *n)
{
	struct node *s = sibling(n);
	s->color = n->parent->color;
	n->parent->color = BLACK;

	if(n->parent->left==n){
		s->right->color = BLACK;
		rotate_left(n->parent);
	}
	else{
		s->left->color = BLACK;
		rotate_right(n->parent);
	}
}

删除修正函数：
在这里插入图片描述

static void rbtree_delete_fixup(RBRoot *root, Node *node, Node *parent)
{
    Node *other;
	//下面的x说的是node
    while ((!node || rb_is_black(node)) && node != root->node)
    {
        if (parent->left == node)
        {
			//删除
            other = parent->right;
            if (rb_is_red(other))
            {
                // Case 1: x的兄弟w是红色的,删除77  
                rb_set_black(other);
                rb_set_red(parent);
                rbtree_left_rotate(root, parent);
                other = parent->right;
            }
            if ((!other->left || rb_is_black(other->left)) &&
                (!other->right || rb_is_black(other->right)))
            {
                // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的,删除65时，删除82时，二级进入循环
                rb_set_red(other);
                node = parent;
                parent = rb_parent(node);
            }
            else
            {
                if (!other->right || rb_is_black(other->right))
                {
                    // Case 3: x的兄弟w是黑色的，并且w的右孩子为黑色。  
                    rb_set_black(other->left);
                    rb_set_red(other);
                    rbtree_right_rotate(root, other);
                    other = parent->right;
                }
                // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                rb_set_color(other, rb_color(parent));
                rb_set_black(parent);
                rb_set_black(other->right);
                rbtree_left_rotate(root, parent);
                node = root->node;
                break;
            }
        }
        else
        {//删除
            other = parent->left;
            if (rb_is_red(other))
            {
                // Case 1: x的兄弟w是红色的  
                rb_set_black(other);
                rb_set_red(parent);
                rbtree_right_rotate(root, parent);
                other = parent->left;
            }
            if ((!other->left || rb_is_black(other->left)) &&
                (!other->right || rb_is_black(other->right)))
            {
                // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的，删除77 
                rb_set_red(other);
                node = parent;
                parent = rb_parent(node);
            }
            else
            {
                if (!other->left || rb_is_black(other->left))
                {
					//删除99时，应该是w的左孩子是黑色
                    // Case 3: x的兄弟w是黑色的，并且w的左孩子是为黑色。  
                    rb_set_black(other->right);
                    rb_set_red(other);
                    rbtree_left_rotate(root, other);
                    other = parent->left;
                }
                // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                rb_set_color(other, rb_color(parent));
                rb_set_black(parent);
                rb_set_black(other->left);
                rbtree_right_rotate(root, parent);
                node = root->node;
                break;
            }
        }
    }
    if (node)
        rb_set_black(node);
}

2 完整代码实现

2.1 rtbtree.h头文件

#ifndef _RED_BLACK_TREE_H_
#define _RED_BLACK_TREE_H_

#define RED 0	//红色结点
#define BLACK 1 //黑色结点

typedef int Type;

//红黑树的结点
typedef struct RBTreeNode {
	unsigned char color;//颜色，RED或者BLACK
	Type key;			//键值
	struct RBTreeNode* left; //左孩子
	struct RBTreeNode* right;//右孩子
	struct RBTreeNode* parent;//父结点
}Node,*RBTree;

//红黑树的根
typedef struct rb_root {
	Node* node;
}RBRoot;

//创建红黑树，返回根
RBRoot* create_rbtree();

//销毁红黑树
void destroy_rbtree(RBRoot* root);

//将结点插入红黑树中。插入成功，返回0，失败返回1
int insert_rbtree(RBRoot* root, Type key);

//删除结点，key为结点的键值
void delete_rbtree(RBRoot* root, Type key);

//前序遍历红黑树
void preorder_rbtree(RBRoot* root);
//中序遍历红黑树
void inorder_rbtree(RBRoot* root);
//后序遍历红黑树
void postorder_rbtree(RBRoot* root);

//递归实现，查找键值为key的值，找到返回0，没找到返回-1
int rbtree_search(RBRoot* root, Type key);
//非递归实现，查找键值为key的值，找到返回0，没找到返回-1
int iterative_rbtree_search(RBRoot* root, Type key);

//返回最小的结点值，保存在val中。找到返回0，否则返回-1
int rbtree_minimum(RBRoot* root, int* val);
//返回最大结点的值,保存到val中。找到返回0；否则返回-1。
int rbtree_maximum(RBRoot* root, int* val);

//打印红黑树
void print_rbtree(RBRoot* root);

#endif

2.2 main.c源文件

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

#define rb_parent(r)	((r)->parent)
#define rb_color(r)		((r)->color)
#define rb_is_red(r)	((r)->color == RED)
#define	rb_is_black(r)	((r)->color == BLACK)
#define	rb_set_black(r)	do {(r)->color = BLACK; } while(0)
#define	rb_set_red(r)	do {(r)->color = RED; } while(0)
#define	rb_set_parent(r,p)	do {(r)->parent = (p); } while(0)
#define	rb_set_color(r,c)	do {(r)->color = (c); } while(0)

//创建红黑树，返回根
RBRoot* create_rbtree()
{
	RBRoot* root = (RBRoot*)malloc(sizeof(RBRoot));
	root->node = NULL;
	return root;
}

//先序遍历红黑树
static void preorder(RBTree tree)
{
	if (tree != NULL) {
		printf("%d ", tree->key);
		preorder(tree->left);
		preorder(tree->right);
	}
}
void preorder_rbtree(RBRoot* root)
{
	if (root)
		preorder(root->node);
}

//中序遍历红黑树
static void inorder(RBTree tree)
{
	if (tree != NULL){
		inorder(tree->left);
		printf("%d ", tree->key);
		inorder(tree->right);
	}
}

void inorder_rbtree(RBRoot* root)
{
	if (root)
		inorder(root->node);
}

//后序遍历红黑树
static void postorder(RBTree tree)
{
	if (tree != NULL){
		postorder(tree->left);
		postorder(tree->right);
		printf("%d ", tree->key);
	}
}

void postorder_rbtree(RBRoot* root)
{
	if (root)
		postorder(root->node);
}


//递归查找键值为key的结点
static Node* search(RBTree x, Type key)
{
	if (x == NULL || x->key == key)
		return x;
	if (key < x->key) {
		return search(x->left, key);
	}
	else return search(x->right, key);
}
int rbtree_search(RBRoot* root, Type key)
{
	if (root)
		return search(root->node, key) ? 0 : -1;
}

//非递归查找键值为key的结点
static Node* iterative_search(RBTree x, Type key)
{
	while ((x != NULL) && (x->key != key)) {
		if (key < x->key) {
			x = x->left;
		}
		else {
			x = x->right;
		}
	}
	return x;
}
int iterative_rbtree_search(RBRoot* root, Type key)
{
	if (root)
		return iterative_search(root->node, key) ? 0 : -1;
}

//查找最小结点
static Node* minimum(RBTree tree)
{
	if (tree == NULL)
		return NULL;

	//由于是二叉搜索树，所以找最小结点一定是树的最左结点
	while (tree->left != NULL){
		tree = tree->left;
	}
	return tree;
}

int rbtree_minimum(RBRoot* root, int* val)
{
	Node* node;
	//有结点，开始搜索
	if (root) {
		node = minimum(root->node);
	}
	//无结点，返回-1
	if (node == NULL) {
		return -1;
	}
	*val = node->key;
	return 0;
}

//查找最大结点
static Node* maximum(RBTree tree)
{
	if (tree == NULL)
		return NULL;

	//由于是二叉搜索树，所以找最小结点一定是树的最右结点
	while (tree->right != NULL)
		tree = tree->right;
	return tree;
}

int rbtree_maximum(RBRoot* root, int* val)
{
	Node* node;

	if (root)
		node = maximum(root->node);

	if (node == NULL)
		return -1;

	*val = node->key;
	return 0;
}

//查找结点x的中序前驱结点，即查找小于该结点key值的最大结点
static Node* rbtree_predecessor(RBTree x)
{
	// 如果左孩子不空，那么就在左子树中搜索最大值
	if (x->left != NULL)
		return maximum(x->left);

	// 如果x没有左孩子。则x有以下两种可能：
	// x是右孩子，那么x的前驱结点是其父结点。
	// x是左孩子，则查找x的最低的父结点结点，并且该父结点要具有右孩子。
	Node* y = x->parent;
	while ((y != NULL) && (x == y->left)){
		x = y;
		y = y->parent;
	}

	return y;
}

//查找结点x的中序后继结点，即查找大于该结点key值的最小结点
static Node* rbtree_successor(RBTree x)
{
	//如果右孩子不空，那么就在右子树中搜索最小值
	if (x->right != NULL)
		return minimum(x->right);
	//如果x没有右孩子，那么需要考虑两种情况
	//如果x是左孩子，那么x的后继结点是其父结点
	//如果x是右孩子，则查找x的最靠近根的父结点，并且该结点必须有左孩子，此结点就是x的后继
	Node* y = x->parent;
	while ((y != NULL) && (y->right == x)) {
		x = y;
		y = y->parent;
	}
	return y;
}

/*
 * 对红黑树的节点(x)进行左旋转
 *
 * 左旋示意图(对节点x进行左旋)：
 *      px                              px
 *     /                               /
 *    x                               y
 *   /  \      --(左旋)-->           / \                #
 *  lx   y                          x  ry
 *     /   \                       /  \
 *    ly   ry                     lx  ly
 *
 *
 */
static void rbtree_left_rotate(RBRoot* root, Node* x)
{
	//将x的右孩子设为y
	Node* y = x->right;

	//将y的左孩子设为x的右孩子，
	//如果y的左孩子非空，将y的左孩子挂到下面
	x->right = y->left;
	if (y->left != NULL)
		y->left->parent = x;

	//将x的父亲改为y的父亲
	y->parent = x->parent;
	//如果x是根结点，那么左旋就需要修改红黑树的根结点
	if (x->parent == NULL) {
		//则将y设为新的根结点
		root->node = y;
	}
	else {
		//如果x是父结点的左孩子，则用y代替x的位置
		if (x->parent->left == x) x->parent->left = y;
		//如果x是父结点的右孩子，则用y替代x的位置
		else x->parent->right = y;
	}
	//将x设为y的左孩子
	y->left = x;
	//将y设为x的父结点
	x->parent = y;
}

/*
 * 对红黑树的节点(y)进行右旋转
 *
 * 右旋示意图(对节点y进行左旋)：
 *            py                               py
 *           /                                /
 *          y                                x
 *         /  \      --(右旋)-->            /  \                     #
 *        x   ry                           lx   y
 *       / \                                   / \                   #
 *      lx  rx                                rx  ry
 *
 */
static void rbtree_right_rotate(RBRoot* root, Node* y)
{
	//设x为y结点的左孩子
	Node* x = y->left;

	//将x的右孩子设为y的左孩子
	//如果x的右孩子不为空，同时将其父亲设为y
	y->left = x->right;
	if (x->right != NULL) {
		x->right->parent = y;
	}

	//将y的父亲设为x的父亲，做旋转操作
	x->parent = y->parent;

	//如果y为根结点，即其没有父结点，此时需要将x设为根结点
	if (y->parent == NULL) {
		root->node = x;
	}
	else {
		//如果y是父结点的左孩子，则用x代替y的位置
		if (y == y->parent->left) y->parent->left = x;
		//如果y是父结点的左孩子，则用x代替y的位置
		else y->parent->right = x;
	}

	//将y设为x的右孩子
	x->right = y;
	//将y的父结点设为x
	y->parent = x;
}

/*
 * 红黑树插入修正函数
 *
 * 在向红黑树中插入节点之后(失去平衡)，再调用该函数；
 * 目的是将它重新塑造成一颗红黑树。
 *
 */
static void rbtree_insert_fixup(RBRoot* root, Node* node)
{
	Node* parent, * gparent;
	//父结点存在，并且父结点颜色是红色
	while ((parent = rb_parent(node)) && rb_is_red(parent)) {
		gparent = rb_parent(parent);
		//父结点是爷结点的左孩子
		if (parent == gparent->left) {
			//Case1：叔结点存在，并且叔结点是红色
			{
				Node* uncle = gparent->right;
				
				if (uncle && rb_is_red(uncle)) {
					rb_set_black(uncle);
					rb_set_black(parent);
					rb_set_red(gparent);
					node = gparent;//将爷结点作为插入结点向上调整
					continue;
				}
			}

			//Case2：叔结点是黑色，当前结点是右孩子，叔结点不存在也认为是黑色
			if (parent->right == node) {
				Node* tmp;
				rbtree_left_rotate(root, parent);//先左旋，然后变成Case3，在右旋
				tmp = parent;
				parent = node;
				node = tmp;
			}

			//Case3: 叔结点是黑色，且当前结点是左孩子
			rb_set_black(parent);
			rb_set_red(gparent);
			rbtree_right_rotate(root, gparent);	
		}
		//父结点是爷结点的右孩子,和上个完全对称的情况
		else {
			//Case1: 叔结点是红色
			{
				Node* uncle = gparent->left;
				if (uncle && rb_is_red(uncle)) {
					rb_set_black(uncle);
					rb_set_black(parent);
					rb_set_red(gparent);
					node = gparent;//向上调整
					continue;//继续调整
				}
			}

			//Case2: 叔结点是黑色，且当前结点是左孩子
			if (parent->left == node) {
				//先左旋，转到Case3，再右旋
				Node* tmp;
				rbtree_right_rotate(root, parent);
				tmp = parent;
				parent = node;
				node = tmp;
			}

			//Case3：叔结点是黑色，且当前结点是右孩子
			rb_set_black(parent);
			rb_set_red(gparent);
			rbtree_left_rotate(root, gparent);
		}
	}

	// 将根结点染黑
	rb_set_black(root->node);
}

/*
 * 添加节点：将节点(node)插入到红黑树中
 *
 */
static void rbtree_insert(RBRoot* root, Node* node)
{
	Node* y = NULL;
	Node* x = root->node;

	//1. 将红黑树当做一颗二叉查找树，将结点添加到二叉查找树中
	while (x != NULL) {
		y = x;
		if (node->key < x->key) x = x->left;
		else x = x->right;
	}
	//让node的父结点指向y
	rb_parent(node) = y;
	//修改父结点的子结点指针
	if (y == NULL) {
		root->node = node;		//情况1，y是空结点，将node设为树根
	}
	else {
		if (node->key < y->key)
			y->left = node;		//情况2，将node设为左孩子
		else y->right = node;	//情况3，将node设为右孩子
	}

	//2. 新结点颜色染红
	node->color = RED;

	//3. 对插入的结点进行颜色修正
	rbtree_insert_fixup(root, node);
}

//创建结点
static Node* create_rbtree_node(Type key, Node* parent, Node* left, Node* right)
{
	Node* p;
	if ((p = (Node*)malloc(sizeof(Node))) == NULL)
		return NULL;
	p->key = key;
	p->left = left;
	p->right = right;
	p->parent = parent;
	p->color = RED; // 默认为红色

	return p;
}

//新建结点，并将其插入到红黑树中
int insert_rbtree(RBRoot* root, Type key)
{
	Node* node;
	//查找是否有相同key的结点
	if (search(root->node, key) != NULL)
		return -1;

	//如果新建结点失败，就返回
	if ((node = create_rbtree_node(key, NULL, NULL, NULL)) == NULL)
		return -1;
	
	rbtree_insert(root, node);

	return 0;
}

//红黑树删除修正函数
static void rbtree_delete_fixup(RBRoot* root, Node* node, Node* parent)
{
	Node* other;
	while ((!node || rb_is_black(node)) && node != root->node) {
		if (parent->left == node) {
			other = parent->right;
			if (rb_is_red(other)) {
				// Case 1: 删除结点的兄弟w是红色，将叔结点染黑，父结点染红，然后左旋处理
				rb_set_black(other);
				rb_set_red(parent);
				rbtree_left_rotate(root, parent);
				other = parent->right;
			}
			if ((!other->left || rb_is_black(other->left)) &&
				(!other->right || rb_is_black(other->right))) {
				//Case 2: 删除结点的兄弟w是黑色，且w的两个孩子都是黑色，直接将叔结点染红即可
				rb_set_red(other);
				node = parent;//继续向上调整
				parent = rb_parent(node);
			}
			else {
				if (!other->right || rb_is_black(other->right)){
					//Case 3: 删除结点的兄弟w是黑色，并且w的右孩子为黑色,先右旋，转为Case4再左旋
					rb_set_black(other->left);
					rb_set_red(other);
					rbtree_right_rotate(root,other);
					other = parent->right;
				}
				//Case 4： 被删除结点的兄弟w是黑色，并且w的右孩子是红色，左孩子任意
				rb_set_color(other, rb_color(parent));
				rb_set_black(parent);
				rb_set_black(other->right);
				rbtree_left_rotate(root, parent);
				node = root->node;
				break;
			}
		}
		else {//完全对称的情况
			other = parent->left;
			if (rb_is_red(other))
			{
				// Case 1: x的兄弟w是红色的  
				rb_set_black(other);
				rb_set_red(parent);
				rbtree_right_rotate(root, parent);
				other = parent->left;
			}
			if ((!other->left || rb_is_black(other->left)) &&
				(!other->right || rb_is_black(other->right)))
			{
				// Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的，删除77 
				rb_set_red(other);
				node = parent;
				parent = rb_parent(node);
			}
			else
			{
				if (!other->left || rb_is_black(other->left))
				{
					//删除99时，应该是w的左孩子是黑色
					// Case 3: x的兄弟w是黑色的，并且w的左孩子是为黑色。  
					rb_set_black(other->right);
					rb_set_red(other);
					rbtree_left_rotate(root, other);
					other = parent->left;
				}
				// Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
				rb_set_color(other, rb_color(parent));
				rb_set_black(parent);
				rb_set_black(other->left);
				rbtree_right_rotate(root, parent);
				node = root->node;
				break;
			}
		}
	}
	//将根结点染黑
	if (node)
		rb_set_black(node);
}

//删除结点
void rbtree_delete(RBRoot* root, Node* node)
{
	Node* child, * parent;
	int color;

	//被删除结点的左右孩子都不为空
	if ((node->left != NULL) && (node->right) != NULL) {
		//被删除结点的后继结点，用来取代删除结点的位置
		Node* replace = node;

		//获取后继结点，有分支最左结点就是我们要找的替换结点
		replace = replace->right;
		while (replace->left != NULL)
			replace = replace->left;

		//删除结点不是根结点，即存在父结点时，开始替换
		if (rb_parent(node)) {
			if (rb_parent(node)->left == node)
				rb_parent(node)->left = replace;
			else rb_parent(node)->right = replace;
		}
		//如果node是根结点，则更新根结点
		else
			root->node = replace;

		//替换结点的右孩子也需要调整，同时替换结点一定没有左孩子
		child = replace->right;
		parent = rb_parent(replace);
		//保存替换结点的颜色，用于后面的判断
		color = rb_color(replace);

		//被删除结点是它后继结点的父结点
		if (parent == node) {
			parent = replace;
		}
		else {
			if (child)
				rb_set_parent(child, parent);
			//因为结点要移到删除位，所以它的右结点，变为其父亲的左结点
			parent->left = child;

			replace->right = node->right;
			eb_set_parent(node->right, replace);
		}

		replace->parent = node->parent;
		replace->color = node->color;
		replace->left = node->left;
		node->left->parent = replace;
		//移除一个红色结点不需要调整，但是移除一个黑色结点会破坏黑路同，需要修正
		if (color == BLACK)
			rbtree_delete_fixup(root, child, parent);
		free(node);
		return;
	}
	//删除结点的一侧是NULL
	if (node->left != NULL)
		child = node->left;
	else child = node->right;
	//获取删除结点的父亲
	parent = node->parent;
	//保存替代结点的颜色
	color = node->color;

	//将孩子结点挂在删除结点下
	if (child)
		child->parent = parent;

	//删除结点不是根结点
	if (parent) {
		//在父亲的左侧，就把自己的孩子放在左侧，在右侧就放在右侧
		if (parent->left == node)
			parent->left = child;
		else parent->right = child;
	}
	else  //如果是根，孩子就变成了根
		root->node = child;

	//删除结点是黑色，需要对其进行修正
	if (color == BLACK)
		rbtree_delete_fixup(root, child, parent);
	free(node);
}


//删除键值为key的结点
void delete_rbtree(RBRoot* root, Type key)
{
	Node* z, * node;

	if ((z = search(root->node, key)) != NULL)
		rbtree_delete(root, z);
}


//销毁红黑树
static void rbtree_destroy(RBTree tree)
{
	if (tree == NULL)
		return;
	if (tree->left != NULL)
		rbtree_destroy(tree->left);
	if (tree->right != NULL)
		rbtree_destroy(tree->right);

	free(tree);
}

void destroy_rbtree(RBRoot* root)
{
	if (root != NULL)
		rbtree_destroy(root->node);

	free(root);
}

//打印红黑树
static void rbtree_print(RBTree tree, Type key, int direction)
{
	if (tree != NULL) {
		if (direction == 0)    // tree是根节点
			printf("%2d(B) is root\n", tree->key);
		else                // tree是分支节点
			printf("%2d(%s) is %2d's %6s child\n", tree->key, rb_is_red(tree) ? "R" : "B", key, direction == 1 ? "right" : "left");

		rbtree_print(tree->left, tree->key, -1);
		rbtree_print(tree->right, tree->key, 1);
	}
}

void print_rbtree(RBRoot* root)
{
	if (root != NULL && root->node != NULL)
		rbtree_print(root->node, root->node->key, 0);
}

#define CHECK_INSERT 1    // "插入"动作的检测开关(0，关闭；1，打开)
#define CHECK_DELETE 1    // "删除"动作的检测开关(0，关闭；1，打开)
#define LENGTH(a) ( (sizeof(a)) / (sizeof(a[0])) )

void main()
{
	int a[] = { 10, 40, 30, 60, 90, 70, 20, 50, 80,65 };
	//int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80,65,66,45,77,99,82,23,55,88,33,47};
	int i, ilen = LENGTH(a);
	RBRoot* root = NULL;

	root = create_rbtree();//给指针申请对应的结构体空间
	printf("== 原始数据: ");
	for (i = 0; i < ilen; i++)
		printf("%d ", a[i]);
	printf("\n");

	for (i = 0; i < ilen; i++)
	{
		insert_rbtree(root, a[i]);
#if CHECK_INSERT
		printf("== 添加节点: %d\n", a[i]);
		printf("== 树的详细信息: \n");
		print_rbtree(root);
		printf("\n");
#endif
	}

	printf("== 前序遍历: ");
	preorder_rbtree(root);

	printf("\n== 中序遍历: ");
	inorder_rbtree(root);

	printf("\n== 后序遍历: ");
	postorder_rbtree(root);
	printf("\n");

	if (rbtree_minimum(root, &i) == 0)
		printf("== 最小值: %d\n", i);
	if (rbtree_maximum(root, &i) == 0)
		printf("== 最大值: %d\n", i);
	printf("== 树的详细信息: \n");
	print_rbtree(root);
	printf("\n");

#if CHECK_DELETE
	for (i = 0; i < ilen; i++)
	{
		printf("== 删除节点: %d\n", a[i]);
		delete_rbtree(root, a[i]);
		if (root)
		{
			printf("== 树的详细信息: \n");
			print_rbtree(root);
			printf("\n");
		}
	}
#endif

	destroy_rbtree(root);
}