C++ 红黑树 - 技术栈

一、红黑树的概念

红黑树是一颗二叉搜索树，它的每一个结点增加一个存储位来表示结点的颜色，可以是红色或者是黑色，通过对任何一条从根到叶子的路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因此是接近平衡的

1.1 红黑树的规则

①：每一个结点不是红色就是黑色

②：根节点是黑色的

③：如果一个结点是红色的，则它的两个孩子结点必须是黑色的，也就是说任意一条路径不会有连续的红色结点

④：对于任意一个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的黑色结点

最坏的情况：

1.2 红黑树如何确保最长路径不超过最短路径的2倍

由规则4可知，从根节点到NULL结点的每条路径都有相同数量的黑色结点，所以极端场景下，最短路径就是全是黑色结点的路径，假设最短路径长度为bh（black height）

由规则2和规则3可知，任意一条路径不会有连续的红色结点，所以极端场景下，最长路径就是一黑一红间隔组成，那么最长路径的长度为2*bh

综合红黑树的4点规则，理论上的全黑最短路径和一黑一红的最长路径并不是在每棵红黑树都存在的，假设任意一条从根到NULL的长度为x，那么bh <= x <= 2*bh

1.3 红黑树的效率

假设N是红黑树中结点数量，h为最短路径的长度，那么2^h - 1 <= N < 2^(2*h) -1,由此推出h约等于logN,也就是意味着红黑树增删查改最坏也就是走最长路径 2 * logN,那么时间复杂度还是O(logN)

红黑树的表达相对AVL树要抽象一些，AVL树通过高度差直观的控制了平衡，红黑树通过4条规则的颜色约束，间接的实现了近似平衡，他们效率都是同一档次，但是相对而言，插入相同数量的结点，红黑树的旋转次数更少，因为其对平衡的控制不是那么严格

二、红黑树的实现

2.1 红黑树的结构

2.2 红黑树的插入

插入的大概过程：

我们假设新增结点为c,c的父结点为p，p的父亲标示为g，p的兄弟标示为u

①：插入一个值按二叉搜索树的规则进行插入，插入后我们只需要观察是否符合红黑树的四条规则

②：如果是空树插入，新增结点是黑色结点，如果是非空树插入，则新增结点必须是红色结点，因为非空树插入新增一个黑色结点会破坏规则四，规则四很难维护，

③：非空树插入后，新增结点必须是红色结点，如果父亲结点是黑色的，则没有违反任何规则，插入结束

④：非空树插入后，新增结点必须是红色结点，如果父亲结点是红色的，则违反了规则3，进一步分析：c是红色，p为红，g必为黑，这三个颜色都固定了，关键变化是u，我们需要根据u的情况分情况处理：

2.2.1 情况1：变色

插入的结点c为红色，c的父结点p也是红色，p的父结点g为黑，p的兄弟u存在且为红，把p和u变黑，g变红，再把g当做新的c,继续往上更新

分析：因为p和u都是红色，g是黑色，，把p和u变黑，左边子树路径各增加一个黑色结点，g再变红，相当于保持g所在子树的黑色结点数量不变，同时解决了c和p连续红色的问题，需要继续往上更新是因为：g是红色，如果g的父亲还是红色，那么就需要我们继续处理，如果g的父亲是黑色，则处理结束了，如果g就是整棵树的根，我们再把g变回黑色

情况一只变色，而不旋转，所以无论c是p的左还是右，都是上面的变色处理：

我们这里只是展示了一种具体的情况，但实际中需要这样处理的有很多情况

现在我们可以将上面类似的处理进行抽象表达，d/e/f代表每条路径拥有hb个黑色结点的子树，

a/b代表每条路径拥有hb-1个黑色结点的根为红的子树

2.2.2 情况2：单旋 + 变色

新插入的结点c是红色，c的父结点p为黑色，u不存在或者u存在且为黑色，u不存在则c一定是新增结点，u存在且为黑，则c一定不是新增的，c之前是黑色的，是在c的子树中插入，符合情况一，变色将c从黑色变成红色，更新上来的

分析：p必须为黑，才能解决，连续红色结点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色

如果p是g的左，c是p的左，那么以g为旋转点进行单右旋，再把p变成黑，g变成红即可，p变成这棵树的根，这样子树黑色结点的数量不变，没有连续的红的结点，且不需要往上更新，因为p的父亲是黑色还是红色都不违反规则

如果p是g的右，c是p的右，那么以g为旋转点进行左单旋，再把p变黑，g变红即可，p变成这棵树的根，这样子树黑色结点的数量不变，没有连续的红色结点，且不再需要继续往上更新，因为同样p的父亲时候红色还是黑色都不会违反规则

2.2.3 情况3：双旋 + 变色

c为红，p为红，p为黑，u不存在或者u存在且为黑，u不存在，则c一定是新增结点，u存在且为黑，则c一定不是新增，c之前是黑色的，是在c的子树中插入，符合情况1，变色将c从黑色变红色，更新上来的

分析：p必须变为黑才能解决，连续红色结点的问题，u不存在或者是黑色的，同样的，这里单纯的变色无法解决问题，需要旋转+变色

如果p是g的左，c是p的右，那么先以p为旋转点进行左单旋，再以g为旋转点进行右单旋，再把c变黑，g变红即可，c变成这棵树新的根，这样子树黑色结点的数量不变，没有连续的红色结点，且不需要再往上更新，因为c的父亲是黑色还是红色或者空都不违反规则

如果p是g的右，c是p的左，那么先以p为旋转点进行单右旋，再以g为旋转点进行左单旋，再把c变黑，g变红即可，c变成这棵树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要再往上更新，因为c的父亲是黑色还是红色或者空都不违反规则

2.3 红黑树的插入代码实现

cpp 复制代码

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			pareent = 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;

	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		//   g
		// p    u
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			if (uncle&& uncle->_col = RED)
			{
				//uncle存在且为红色,只需要我们变色再继续往上处理
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				cur = grandfather;
				parent = cur->_parent;
			}
			else {
				//uncle不存在，这时需要我们旋转加变色解决
				if (cur == parent->_left)
				{
					//     g
					//  p     u
					//c
					//此时右单旋即可
					RotateR(grandfather);
					//变色的规则：p变黑，g变红
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else {
					//     g
					//  p     u
					//      c
					//此时要双旋才能解决（左右双旋）
					RotateL(parent);
					Rotate(grandfather);

					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else {
			//   g
			// u   p
			Node* uncle = grandfather->_left;
			if (uncle&& uncle->_col = RED)
			{
				//叔叔存在且为红，只需要变色即可
				//   g
				// u   p
				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
					Rotate(parent);
					Rotate(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return true;
}

2.4 红黑树的查找

cpp 复制代码

Node* find(const k& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < key)
		{
			cur = cur->_right;
		}
		else if (cur->_kv.first > key)
		{
			cur = cur->_left;
		}
		else {
			return cur;
		}
	}
	return nullptr;
}

2.5 红黑树的验证

cpp 复制代码

bool Check(Node* root, int blackNum, const int 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);
}
bool IsBalance()
{
	if (_root == nullptr)
		return true;
	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);
}