红 黑 树

AVL树是严格平衡的。

红⿊树是⼀棵⼆叉搜索树。 通过对任何⼀条从根到叶⼦的路径上各个结点的颜⾊进⾏约束，红⿊树确保没有⼀条路径会⽐其他路径⻓出2倍，因⽽是接近平衡的。即最长路径<=最短路径的2倍。

红黑树规则：

1. 每个结点不是红⾊就是⿊⾊

2. 根结点是⿊⾊的

3. 如果⼀个结点是红⾊的，则它的两个孩⼦结点必须是⿊⾊的，也就是说任意⼀条路径不会有连续的 红⾊结点。即不存在连续红色的。

4. 对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的⿊⾊结点。即每条路径的黑色节点的个数相等。（比较严格）

新插入节点插入红色。如果插入黑色就一定会违反规则4，因为规则4比较严格，所以不要破坏规则4。

 红黑树的抽象图：

情况一：cur是新增节点，cur是红，p是红，u是红且存在，g是黑。

变换规则是：

 

代码如下所示：

	//1.叔叔存在且是红。p变黑，u变黑，g变红。如果g是根再次变黑，否则继续向上更新。
	if (uncle && uncle->_col == RED)
	{
		parent->_col = uncle->_col = BLACK;
		grandfather->_col = RED;

		cur = parent;//继续向上更新
		parent = cur->_parent;
	}
	//2.叔叔不存在/存在且是黑
	else
	{
		if (cur == parent->_left)//单旋
		{
			//     g                 p
			//   p   u------>     c    g
			// c                          u
			RotateR(grandfather);
			parent->_col = BLACK;
			grandfather->_col = RED;
		}
		else//双旋
		{
			//      g                 g            c
			//   p     u    ->      c    u   ->  p     g
			//      c             p                        u
			RotateL(parent);
			RotateR(grandfather);
			cur->_col = BLACK;
			grandfather->_col = RED;
		}
		break;
	}
}

情况二：cur是新增节点，cur是红，p是红，g是黑，u不存在/存在且为黑。

 情况二还有一种情况是双旋+变色。具体的实现代码如下所示：

	//2.叔叔不存在/存在且是黑
else
{
				if (cur == parent->_left)//单旋
				{
					//     g                 p
					//   p   u------>     c    g
					// c                          u
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else//双旋
				{
					//      g                 g            c
					//   p     u    ->      c    u   ->  p     g
					//      c             p                        u
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
}

 整体代码如下：

enum Colour
{
	RED,
	BLACK
};
template
struct RBTreeNode {
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	pair _kv;
	Colour _col;

	RBTreeNode(const pair& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(RED)
	{}
};


template
class RBTree
{
	typedef RBTreeNode Node;
public:
	bool Insert(const pair& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);//插入新节点
		cur->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//当父亲不为空且父亲是红色的时候，关键是看叔叔，分两种情况：1.叔叔存在且是红。2.叔叔不存在/存在且是黑
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)//叔叔在爷爷的右边
			{
				Node* uncle = grandfather->_right;

				//1.叔叔存在且是红。p变黑，u变黑，g变红。如果g是根再次变黑，否则继续向上更新。
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = parent;//继续向上更新
					parent = cur->_parent;
				}
				//2.叔叔不存在/存在且是黑
				else
				{
					if (cur == parent->_left)//单旋
					{
						//     g                 p
						//   p   u------>     c    g
						// c                          u
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//双旋
					{
						//      g                 g            c
						//   p     u    ->      c    u   ->  p     g
						//      c             p                        u
						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 // 叔叔不存在，或者存在且为黑
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}


	void RotateR(Node* parent)//右旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;

		Node* ppNode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}

			subL->_parent = ppNode;
		}
	}


	void RotateL(Node* parent)//左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		Node* ppNode = parent->_parent;

		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_right == parent)
			{
				ppNode->_right = subR;
			}
			else
			{
				ppNode->_left = subR;
			}
			subR->_parent = ppNode;
		}
	}

	bool IsBalance()//判断是否平衡，满足规则。
	{
		if (_root->_col == RED)
		{
			return false;
		}

		int refNum = 0;
		Node* cur = _root;
		while (cur)//先找一条路劲计算黑色节点个数，与其他比较。
		{
			if (cur->_col == BLACK)
			{
				++refNum;
			}

			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}
	private:
		bool Check(Node* root, int blackNum, const int refNum)//refNum先找一个参考值计算黑色节点的个数。
		{
			if (root == nullptr)
			{
				if (refNum != blackNum)
				{
					cout << "存在黑色节点的数量不相等的路径" << endl;
					return false;
				}

				return true;
			}

			if (root->_col == RED && root->_parent->_col == RED)
			{
				cout << root->_kv.first << "存在连续的红色节点" << endl;
				return false;
			}

			if (root->_col == BLACK)
			{
				blackNum++;
			}

			return Check(root->_left, blackNum, refNum)
				&& Check(root->_right, blackNum, refNum);
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_kv.first << ":" << root->_kv.second << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
};