数据结构——红黑树（半）

目录

什么是红黑树

红黑树的基本了解

红黑树的基本特征

红黑树的基本操作

需要使用的其他函数

（1）红黑树节点

（2）哨兵节点，用于回溯判断

（2）增加节点函数

（4）创造根节点

旋转

插入

过程

代码

回溯

分析

代码

---

什么是红黑树

红黑树的基本了解

（1）红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。

（2）红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 [2] 

（3）它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。

（4）红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），但 对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。

（5）由于每一棵红黑树都是一颗二叉排序树，因此，在对红黑树进行查找时，可以采用运用于普通二叉排序树上的查找算法，在查找过程中不需要颜色信息。

红黑树的基本特征

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

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

性质2. 根结点是黑色。 

性质3. 所有叶子都是黑色。（叶子是NIL结点） 

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

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

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

性质4导致路径上不能有两个连续的红色结点确保了这个结果。最短的可能路径都是黑色结点，最长的可能路径有交替的红色和黑色结点。因为根据性质5所有最长的路径都有相同数目的黑色结点，这就表明了没有路径能多于任何其他路径的两倍长。 

因为红黑树是一种特化二叉查找树，所以红黑树上的只读操作与普通二叉查找树相同。 

红黑树的基本操作

需要使用的其他函数

（1）红黑树节点

typedef enum { RED = 0, BLACK = 1 } ColorType;

typedef int KeyType;
typedef struct rb_node
{
	rb_node* leftchild;
	rb_node* parent;
	rb_node* rightchild;
	ColorType color; 
	KeyType key;
}rb_node, * RBTree;

（2）哨兵节点，用于回溯判断

static  rb_node* Nil = Buynode();

（2）增加节点函数

rb_node* Buynode()
{
	rb_node* s = (rb_node*)malloc(sizeof(rb_node));
	if (nullptr == s) exit(1);
	memset(s, 0, sizeof(rb_node));
	s->leftchild = Nil;
	s->rightchild = Nil;
	s->color = RED;
	return s;
}

（4）创造根节点

rb_node* MakeRoot(KeyType kx)
{
	rb_node* root = Buynode();
	root->color = BLACK;
	root->key = kx;
	return root;
}

旋转

对于红黑树的旋转和avl树的旋转没有什么不同，我的博客AVL树（点击）对做单旋，右单旋，左右双旋转，右左双旋转，有特别详细的描述；

代码如下：

void RotateLeft(rb_node*& tree, rb_node* ptr)
{
	rb_node* newroot = ptr->rightchild;
	newroot->parent = ptr->parent; // 1
	ptr->rightchild = newroot->leftchild;
	if (newroot->leftchild != nullptr)
	{
		newroot->leftchild->parent = ptr;  // 2
	}
	newroot->leftchild = ptr;
	if (ptr == tree)
	{
		tree = newroot;
	}
	else
	{
		if (ptr->parent->leftchild == ptr)
		{
			ptr->parent->leftchild = newroot;
		}
		else
		{
			ptr->parent->rightchild = newroot;
		}
	}
	ptr->parent = newroot;	 //3
}

void RotateRight(rb_node*& tree, rb_node* ptr)
{
	rb_node* newroot = ptr->leftchild;
	newroot->parent = ptr->parent; //1
	ptr->leftchild = newroot->rightchild;
	if (newroot->rightchild != nullptr)
	{
		newroot->rightchild->parent = ptr;
	}
	newroot->rightchild = ptr;
	if (ptr == tree)
	{
		tree = newroot;
	}
	else
	{
		if (ptr->parent->leftchild == ptr)
		{
			ptr->parent->leftchild = newroot;
		}
		else
		{
			ptr->parent->rightchild = newroot;
		}
	}
	ptr->parent = newroot;
}

插入

过程

插入过程首先是根据一般二叉查找树的插入步骤， 把新结点 插入到 某个叶结点的位置上，然后将 新节点着为红色。 为了保证红黑树的性质能继续保持，再对有关结点重点着色并旋转，其插入算法如下： 

1 按二叉查找树的插入步骤将结点新节点插入到 树tree中；

2 如果前面没有节点，则置为根节点（结束）；

3 找到插入的位置，判断是双亲结点的左孩子还是右孩子；

4 从插入节点开始回溯，调整红黑树的结构使其满足上述五个性质；

插入函数简单；对于代码中的回溯函数，会重点分析；

代码

bool Insert(rb_node*& tree, KeyType kx)
{
	if (tree == nullptr)
	{
		tree = MakeRoot(kx);
		return true;
	}
	rb_node* pa = nullptr;
	rb_node* p = tree;
	while (p != nullptr && p->key != kx)//找到插入位置
	{
		pa = p;
		p = kx < p->key ? p->leftchild : p->rightchild;
	}
	if (p != nullptr && p->key == kx) return false;
	p = Buynode();//购买节点
	p->key = kx;
	p->parent = pa;
	if (kx < pa->key)//判断是左右那个孩子
	{
		pa->leftchild = p;
	}
	else
	{
		pa->rightchild = p;
	}
	PassRBTree(tree, p);
	return true;
}

回溯

分析

维持红黑树的平衡有两种方式，通过改变颜色来使其平衡，通过旋转来保持平衡；

（1）case1：添加在节点的右边，对于这个来说，无法通过改变颜色（根节点不能是红色），所以通过左单旋转保持平衡，如图一；

（2）case2：在图一平衡的基础上，在右孩子插入，祖父节点的左孩子为红色，则可以通过改变颜色去保持平衡，如图二；

（3）case3：在再右孩子插入，但是祖父节点的左边没有节点（哨兵节点（黑）），只能通过旋转来保持和平衡，如图三；

（4）case4：在右孩子的左边插入，与case3其他情况相同，所以只能通过旋转，但是单旋转不行，只能通过右左双旋转来保持平衡，如图4；

每次平衡化之后都要将根节点置为黑色； 

代码

void PassRBTree(rb_node*& tree, rb_node* p)
{
	rb_node* _X = nullptr;
	for (; p != tree && p->parent->color == RED;)
	{
		if (p->parent->parent->rightchild == p->parent)	 // ringht
		{
			_X = p->parent->parent->leftchild;
			if (_X->color == RED)
			{
				_X->color = BLACK;
				p->parent->color = BLACK;
				p->parent->parent->color = RED;
				p = p->parent->parent;
			}
			else
			{
				if (p->parent->leftchild == p)
				{
					p = p->parent;
					RotateRight(tree, p);
				}
				p->parent->color = BLACK;
				p->parent->parent->color = RED;
				RotateLeft(tree, p->parent->parent);
			}
		}
		else
		{
			_X = p->parent->parent->rightchild;
			if (_X->color == RED)
			{
				_X->color = BLACK;
				p->parent->color = BLACK;
				p->parent->parent->color = RED;
				p = p->parent->parent;
			}
			else
			{
				if (p->parent->rightchild == p)
				{
					p = p->parent;
					RotateLeft(tree, p);
				}
				p->parent->color = BLACK;
				p->parent->parent->color = RED;
				RotateRight(tree, p->parent->parent);
			}
		}
	}
	tree->color = BLACK;
}