【数据结构】红黑树

一、概念：（参考百科）

1数据结构

红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log )时间内做查找，插入和删除，这里的是树中元素的数目。

它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。其他平衡树还有：AVL，SBT，伸展树，TREAP 等等。

性质

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

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

性质2. 根节点是黑色。

性质3 每个叶节点是黑色的。

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

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

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

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

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

背景和术语

红黑树是一种特定类型的二叉树，它是在计算机科学中用来组织数据比如数字的块的一种结构。所有数据块都存储在节点中。这些节点中的某一个节点总是担当启始位置的功能，它不是任何节点的儿子；我们称之为根节点或根。它有最多两个"儿子"，都是它连接到的其他节点。所有这些儿子都可以有自己的儿子，以此类推。这样根节点就有了把它连接到在树中任何其他节点的路径。

如果一个节点没有儿子，我们称之为叶子节点，因为在直觉上它是在树的边缘上。子树是从特定节点可以延伸到的树的某一部分，其自身被当作一个树。在红黑树中，叶子被假定为 null 或空。

由于红黑树也是二叉查找树，它们当中每一个节点的比较值都必须大于或等于在它的左子树中的所有节点，并且小于或等于在它的右子树中的所有节点。这确保红黑树运作时能够快速的在树中查找给定的值。

用途和好处

红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可能的最坏情况担保。这不只是使它们在时间敏感的应用如即时应用(real time application)中有价值，而且使它们有在提供最坏情况担保的其他数据结构中作为建造板块的价值；例如，在计算几何中使用的很多数据结构都可以基于红黑树。

红黑树在函数式编程中也特别有用，在这里它们是最常用的持久数据结构之一，它们用来构造关联数组和集合，在突变之后它们能保持为以前的版本。除了O(log n)的时间之外，红黑树的持久版本对每次插入或删除需要O(log n)的空间。

红黑树是 2-3-4树的一种等同。换句话说，对于每个 2-3-4 树，都存在至少一个数据元素是同样次序的红黑树。在 2-3-4 树上的插入和删除操作也等同于在红黑树中颜色翻转和旋转。这使得 2-3-4 树成为理解红黑树背后的逻辑的重要工具，这也是很多介绍算法的教科书在红黑树之前介绍 2-3-4 树的原因，尽管 2-3-4 树在实践中不经常使用。

操作

在红黑树上只读操作不需要对用于二叉查找树的操作做出修改，因为它也是二叉查找树。但是，在插入和删除之后，红黑属性可能变得违规。恢复红黑属性需要少量(O(log n))的颜色变更(这在实践中是非常快速的)并且不超过三次树旋转(对于插入是两次)。这允许插入和删除保持为 O(log n) 次，但是它导致了非常复杂的操作。

 

二、图解：（参考知乎）

（参考https://zhuanlan.zhihu.com/p/41508701）

下图中这棵树，就是一颗典型的红黑树：

红黑树的5条性质，保证了红黑树的自平衡。红黑树从根到叶子的最长路径不会超过最短路径的2倍。
当插入或删除结点的时候，红黑树的规则有可能被打破。这时候就需要作出一些调整，来继续我们的规则。

什么情况下会破坏红黑树的规则，什么情况下不会破坏规则呢？我们举两个简单的栗子：

1.向原红黑树插入值为14的新节点：

2.向原红黑树插入值为21的新节点：

 由于父节点22是红色节点，因此这种情况打破了红黑树的规则4（每个红色节点的两个子节点都是黑色），必须进行调整，使之重新符合红黑树的规则。

调整方式有两种：【变色】和【旋转】。而【旋转】又分为【左旋转】和【右旋转】。
变色：

为了重新符合红黑树的规则，尝试把红色节点变为黑色，或者把黑色节点变为红色。

下图所表示的是红黑树的一部分，需要注意节点25并非根节点。因为节点21和节点22连续出现了红色，不符合规则4，所以把节点22从红色变成黑色：

 但这样并不算完，因为凭空多出的黑色节点打破了规则5，所以发生连锁反应，需要继续把节点25从黑色变成红色：

 此时仍然没有结束，因为节点25和节点27又形成了两个连续的红色节点，需要继续把节点27从红色变成黑色：

 

左旋转：

逆时针旋转红黑树的两个节点，使得父节点被自己的右孩子取代，而自己成为自己的左孩子。说起来很怪异，大家看下图：

 

 

图中，身为右孩子的Y取代了X的位置，而X变成了自己的左孩子。此为左旋转。

右旋转：

顺时针旋转红黑树的两个节点，使得父节点被自己的左孩子取代，而自己成为自己的右孩子。大家看下图：

 图中，身为左孩子的Y取代了X的位置，而X变成了自己的右孩子。此为右旋转。

红黑树的插入和删除包含很多种情况，每一种都需要不同的处理方式。这里举例：

我们以刚才插入节点21的情况为例：

首先，我们需要做的是变色，把节点25及其下方的节点变色：

 

此时节点17和节点25是连续的两个红色节点，那么把节点17变成黑色节点？恐怕不合适。这样一来不但打破了规则4，而且根据规则2（根节点是黑色），也不可能把节点13变成红色节点。

变色已无法解决问题，我们把节点13看做X，把节点17看做Y，像刚才的示意图那样进行左旋转：

 

 

 由于根节点必须是黑色节点，所以需要变色，变色结果如下：

这样就结束了吗？并没有。因为其中两条路径(17 -> 8 -> 6 -> NIL)的黑色节点个数是4，其他路径的黑色节点个数是3，不符合规则5。

这时候我们需要把节点13看做X，节点8看做Y，像刚才的示意图那样进行右旋转：

最后根据规则来进行变色：

 

如此一来，我们的红黑树变得重新符合规则。这一个例子的调整过程比较复杂，经历了如下步骤：

变色 -> 左旋转 -> 变色 -> 右旋转 -> 变色

 

三、代码实现

1.结构定义：

typedef int KeyType;  //树中存储的数据类型
typedef enum {RED = 0, BLACK = 1} ColorType;  //枚举类型：颜色类型
struct rb_node  //树的结点
{
	rb_node *leftchild;
	rb_node *parent;// BST AVL RB B 
	rb_node *rightchild;
	ColorType color;
	KeyType key;
};
typedef struct //树
{
	rb_node * head;  //头结点
	rb_node * Nil;   //哨兵结点
	int cursize;     //树的结点个数
}RBTree;

rb_node * Buynode(rb_node *pa = NULL,ColorType color = RED) //new一个结点，颜色默认为红色
{
	rb_node *s = (rb_node*)malloc(sizeof(rb_node));
	if(NULL == s) exit(1);
	memset(s,0,sizeof(rb_node));
	s->parent = pa;
	s->color = color;
	return s;
}
void Freenode(rb_node *p) //释放结点
{
	free(p);
}

void InitRBTree(RBTree &myt)  //初始化一棵树
{
	myt.Nil = Buynode(NULL,BLACK); //首先初始化哨兵 颜色为黑
	myt.head = Buynode(myt.Nil); //树的头结点head          // root;
	myt.head->leftchild = myt.Nil;
	myt.head->rightchild = myt.Nil;
	myt.cursize = 0;
}

2.左旋、右旋：和AVL树一样，要考虑3个重新指向，相应的3个parent重新指向

void RotateLeft(rb_node *head,rb_node *ptr)
{
	rb_node *newroot = ptr->rightchild;//#
	newroot->parent = ptr->parent; // 1
	ptr->rightchild = newroot->leftchild; // #
	if(newroot->leftchild != NULL)
	{
		newroot->leftchild->parent = ptr; //2
	}
	
	newroot->leftchild = ptr;  // #
	if(ptr == head->parent) // ptr => root;
	{
		head->parent = newroot;
	}
	else
	{
		if(ptr->parent->leftchild == ptr)
		{
			ptr->parent->leftchild = newroot;
		}
		else
		{
			ptr->parent->rightchild = newroot;
		}
	}
	ptr->parent = newroot; // 3
}
void RotateRight(rb_node *head, rb_node *ptr)
{
	rb_node *newroot = ptr->leftchild;
	newroot->parent = ptr->parent; // 1
	ptr->leftchild = newroot->rightchild;
	if(newroot->rightchild != NULL)
	{
		newroot->rightchild->parent = ptr; //2
	}
	newroot->rightchild = ptr;
	if(ptr == head->parent)
	{
		head->parent = newroot;
	}
	else
	{
		if(ptr->parent->leftchild == ptr)
		{
			ptr->parent->leftchild = newroot;
		}
		else
		{
			ptr->parent->rightchild = newroot;
		}
	}
	ptr->parent = newroot; // 3
}

3.插入结点：考虑重复、插入适当位置，调整头结点的最大最小指向

bool InsertItem(RBTree &myt,KeyType kx)
{
	rb_node * pa = myt.head;       // head
	rb_node *p = myt.head->parent; // root
	while(p != myt.Nil && p->key != kx)
	{
		pa = p;
		p = kx < p->key? p->leftchild : p->rightchild;
	}
	if(p != myt.Nil  && p->key == kx) return false;

	p = Buynode(pa);
	p->key = kx;
	myt.cursize +=1;
	if(pa == myt.head)
	{
		myt.head->parent = p;
		myt.head->leftchild = p;
		myt.head->rightchild = p;
	}
	else
	{
		if(p->key < pa->key)
		{
			pa->leftchild = p;
			if(myt.head->leftchild->key > p->key)
			{
				myt.head->leftchild = p;
			}
		}
		else
		{
			pa->rightchild = p;
			if(myt.head->rightchild->key < p->key)
			{
				myt.head->rightchild = p;
			}
		}

		Adjust_RBTree(myt,p);
	}

	return true;
}

4.调整树：重点、难点

如图：