C++ 红黑树

一，红黑树的概念

红黑树，是一种二叉搜索树，在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

二，红黑树的性质

1. 每个结点不是红色就是黑色 。
2. 根节点是黑色的 。
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 。（不能有连续的红节点）
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 。
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)。
   红黑树没有规定不可以有连续的黑节点。
   思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？
   对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 。
   红黑树极限最短为全黑，极限最长为一黑一红，且黑节点数目一样，所以可以保证。

三， 红黑树的节点的定义

和AVL树类似，不过红黑树没有平衡因子，并且新增了节点的颜色，颜色我们用枚举来表示，红黑树是靠控制上面的几个性质来近似的保证平衡的。

四，红黑树的插入

插入规则和二叉搜索树的规则相同。
可是将数据插入进去，就要给它赋予一种颜色，那么应该是黑色还是红色呢？
如果新插入的节点为黑色，那么就会违反性质四，并且会影响整棵树的结构。
如果新插入的节点为红色，虽然会违反性质三，但是他只会影响局部的子树，我们通过------旋转+变色来消除这种影响。

插入节点后，我们要检测红黑树性质是否被遭到破坏。
因为新节点的默认颜色是红色，所以如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连续在一起的红色节点，此时需要对红黑树分情况来讨论：
约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点
我们分三种情况：
一，cur为红，p为红，g为黑，u存在且为红。
（1）g是根节点。
将父亲（p）和叔叔(u)变黑,祖父变黑，结束。

（2）g是一颗子树中的节点。
将父亲（p）和叔叔(u)变黑,祖父变红。因为g是一颗子树，那么它肯定有双亲。
情况一，如果g的双亲是黑色，那么调整结束。
情况二， 如果g的双亲是红色，那么在插入节点之后导致g变成红色，又出现了两个连续的红节点，所以要继续向上迭代，将cur=g;p=cur->_parent;g=p->_parent,继续将父亲（p）和叔叔(u)变黑,祖父变红，直到p为空或者p的颜色是黑色就结束，最后将根节点变黑。

二，cur为红，p为红，g为黑，u不存在/u存在且为黑。
（1）u不存在。
u不存在，cur一定是新增节点，如果cur不是新增节点，那么p和cur一定有一个是黑色，此时每条路径的黑节点数目不相同。
（2）u存在且为黑。
u存在且为黑，那么cur原来一定是黑色的，现在看是红色的是因为cur在调整阶段颜色由黑色变为了红色。

========================================================================
处理：（1）如果p是g的左孩子，cur是p的左孩子，那就进行右单旋。
（2） 如果p是g的右孩子，cur是p的右孩子，那就进行左单旋。
旋转完之后，将g的颜色变红，p的颜色变黑。


左单旋和右单旋类似。
二，cur为红，p为红，g为黑，u不存在/u存在且为黑。
（1）u不存在。
（2）u存在且为黑。

======================================================================
处理：（1）如果p是g的左孩子，cur是p的右孩子，那就进行左右双旋。
（2） 如果p是g的右孩子，cur是p的左孩子，那就进行右左双旋。
旋转完之后，将g的颜色变红，cur的颜色变黑。

右左双旋和左右双旋类似。
代码：

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		//插入节点完成，并且插入的节点颜色是红的
		//接下来开始分情况进行更新颜色
		while (parent && parent->_col == RED)
		{	
			Node* grandfather= parent->_parent;
			assert(grandfather);
			assert(grandfather->_col == BLACK);
			//在这里grandparent一定不为空；
			if (grandfather->_left == parent)
			{
				//情况一：p为红，c为红，g为黑，uncle存在且为红
				//将p,u变为黑，
				Node* uncle = grandfather->_right;
				if (uncle&& uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
						cur = grandfather;
					  parent=cur->_parent ;
				}
				//情况二+三：p为红，c为红，g为黑，uncle不存在/存在且为黑
				else
				{   
					if (parent->_left == cur)//右旋
					{
                         RotateR(grandfather);
				    	 parent->_col = BLACK;
						 grandfather->_col = RED;
					}	
					else
					{
                     RotateL(parent);//左右双旋
					 RotateR(grandfather);
					 cur->_col = BLACK;
					 grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (parent->_right == cur)//左单旋
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);//右左双旋
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
	   _root->_col = BLACK;
	   return true;
	}

void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* ppNode = parent->_parent;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		parent->_parent = subR;
		if (_root == parent) {
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	void RotateR(Node* parent)//右旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (ppNode == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}

五， 红黑树删除

红黑树删除太复杂，这里不赘述。

六， 红黑树验证

1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)。
2. 检测其是否满足红黑树的性质。

七，红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(log2 N)，红黑树不追
求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，
所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红
黑树更多。