C++ 红黑树自平衡核心：旋转变色、规则详解与 STL 选型逻辑

观众老爷们大家好 我是邪修KING 本文属于系列C++ 进阶篇 ，欢迎来到C++进阶篇博客 C++重点语法运用！ >本文属于 《C++ 进阶篇系统教程》第 6 篇，上一篇我们讲透了红黑树的通用化设计 ------ 用仿函数、迭代器和\[\]运算符实现了 set 和 map 的核心功能。今天我们深入红黑树的灵魂：**自平衡机制**。这是红黑树能保证 O (logn) 稳定性能的核心，也是校招面试的绝对高频考点！

一、红黑树的概念

红⿊树是⼀棵⼆叉搜索树，他的每个结点增加⼀个存储位来表⽰结点的颜⾊，可以是红⾊或者⿊⾊。

通过对任何⼀条从根到叶⼦的路径上各个结点的颜⾊进⾏约束，红⿊树确保没有⼀条路径会⽐其他路

径⻓出2倍，因⽽是接近平衡的。

1.1红黑树四大规则（性质）

1. 每个结点不是红⾊就是⿊⾊
2. 根结点是⿊⾊的
3. 如果⼀个结点是红⾊的，则它的两个孩⼦结点必须是⿊⾊的，也就是说任意⼀条路径不会有连续的
   红⾊结点。
4. 对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的⿊⾊结点
   **注意！**红黑树任意一个节点到最终结点的所有NULL结点的路径，统计所有黑色结点的个数必须一样！
   说明：《算法导论》等书籍上补充了⼀条每个叶⼦结点(NIL)都是⿊⾊的规则。他这⾥所指的叶⼦结点
   不是传统的意义上的叶⼦结点，⽽是我们说的空结点，有些书籍上也把NIL叫做外部结点。NIL是为了
   ⽅便准确的标识出所有路径，《算法导论》在后续讲解实现的细节中也忽略了NIL结点，所以我们知道
   ⼀下这个概念即可。形象如图：
   

1.2 红黑树最长路径不超过最短路径的2倍

• 由规则4可知，从根到NULL结点的每条路径都有相同数量的⿊⾊结点，所以极端场景下，最短路径

就就是全是⿊⾊结点的路径，假设最短路径⻓度为bh(black height)。

• 由规则2和规则3可知，任意⼀条路径不会有连续的红⾊结点，所以极端场景下，最⻓的路径就是⼀

⿊⼀红间隔组成，那么最⻓路径的⻓度为2bh。
• 综合红⿊树的4点规则⽽⾔，理论上的全⿊最短路径和⼀⿊⼀红的最⻓路径并不是在每棵红⿊树都
存在的。假设任意⼀条从根到NULL结点路径的⻓度为x，那么bh <= h <= 2bh。

1.3 红⿊树的效率：

假设N是红⿊树树中结点数量，h最短路径的⻓度，那么也就是意味着红⿊树增删查改最坏也就是⾛最⻓路径 ，那么时间复杂度还是O(logN)

红⿊树的表达相对AVL树要抽象⼀些，AVL树通过⾼度差直观的控制了平衡。红⿊树通过4条规则的颜

⾊约束，间接的实现了近似平衡，他们效率都是同⼀档次，但是相对⽽⾔，插⼊相同数量的结点，红

⿊树的旋转次数是更少的，因为他对平衡的控制没那么严格。

二、红黑树的实现

红黑树的插入分为两步：

1、按照普通 BST 的规则插入新节点

2、调整颜色和旋转，恢复红黑树的性质

2.1 为什么新节点默认是红色？

新节点默认插入为红色，这是一个非常巧妙的设计：

如果插入黑色节点，必然会破坏性质 5（黑高不一致），需要调整整条路径

如果插入红色节点，只会可能破坏 性质 4（不能有连续红色），只需要局部调整

插入红色节点后，只有当父节点也是红色时，才会破坏性质 4，需要进行平衡调整。如果父节点是黑色，不需要任何调整，直接满足所有性质。

2.2 平衡调整的三种情况

我们约定：

cur：当前新插入的节点（红色）

parent：cur 的父节点（红色）

grandfather：parent 的父节点（黑色，因为 parent 是红色，根据性质 4，祖父一定是黑色）

uncle：parent 的兄弟节点（叔叔）

根据uncle的颜色和位置，平衡调整分为三种情况：

2.2.1情况1：变色

c为红，p为红，g为⿊，u存在且为红，则将p和u变⿊，g变红。在把g当做新的c，继续往上更新。

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

情况1只变色，不旋转 。所以⽆论c是p的左还是右，p是g的左还是右，都是上⾯的变⾊处理⽅式。

具体情况如下图：

跟AVL树类似，图0我们展⽰了⼀种具体情况，但是实际中需要这样处理的有很多种情况。

• 图1将以上类似的处理进⾏了抽象表达，d/e/f代表每条路径拥有hb个⿊⾊结点的⼦树，a/b代表每

条路径拥有hb-1个⿊⾊结点的根为红的⼦树，hb>=0。

• 图2/图3/图4，分别展⽰了hb == 0/hb == 1/hb == 2的具体情况组合分析，当hb等于2时，这⾥组合

情况上百亿种，这些样例是帮助我们理解，不论情况多少种，多么复杂，处理⽅式⼀样的，变⾊再

继续往上处理 即可，所以我们只需要看抽象图即可。

注意：最后更新g为头节点后

将g转为cur节点继续循环向上变色

2.2.2单旋+变色

c为红，p为红，g为⿊，u不存在或者u存在且为⿊，u不存在，则c⼀定是新增结点，u存在且为⿊，则c⼀定不是新增，c之前是⿊⾊的，是在c的⼦树中插⼊，符合情况1，变⾊将c从⿊⾊变成红⾊，更新上来的。

分析：p必须变⿊，才能解决，连续红⾊结点的问题，u不存在或者是⿊⾊的，这⾥单纯的变⾊⽆法解决问题，需要旋转+变⾊。

如果p是g的左，c是p的左，那么以g为旋转点进⾏右单旋，再把p变⿊，g变红即可。p变成课这颗树新的根，这样⼦树⿊⾊结点的数量不变，没有连续的红⾊结点了，且不需要往上更新，因为p的⽗亲是⿊⾊还是红⾊或者空都不违反规则。

如果p是g的右，c是p的右，那么以g为旋转点进⾏左单旋，再把p变⿊，g变红即可。p变成课这颗树新

的根，这样⼦树⿊⾊结点的数量不变，没有连续的红⾊结点了，且不需要往上更新，因为p的⽗亲是⿊⾊还是红⾊或者空都不违反规则。

如图（其中一类）：

情况分析：（单旋变色）

1.u不存在，则c 一定是新增 结点。

假如c不是新增结点，那么3结点在最初的时候是黑色的，于是10->6->3路径下就会有2个黑色结点，而10->NIL路径下只有一个黑色结点，破坏了规则四。

2.u存在且为黑，则c 一定不是新增结点

2.2.3 情况2：双旋+变色

c为红，p为红，g为⿊，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红黑树代码实现

#pragma once

enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	// 这里更新控制平衡也要加入parent指针
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	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)
			{
				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;

		// 父亲是红色，出现连续的红色节点，需要处理
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				//   g
				// p   u
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						//     g
						//   p    u
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//      g
						//   p    u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else
			{
				//   g
				// u   p
				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
					{
						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;

		Node* pParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

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

			subL->_parent = pParent;
		}
	}

	void RotateL(Node * parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

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

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}

	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;
	}

	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);
	}

private:

	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			// 前序遍历走到空时，意味着一条路径走完了
			//cout << blackNum << endl;
			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);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	int _Size(Node* root)
	{
		if (root == nullptr)
			return 0;

		return _Size(root->_left) + _Size(root->_right) + 1;
	}

private:
	Node* _root = nullptr;
};

三、删除操作的平衡调整（了解即可）

删除操作比插入复杂得多，因为删除黑色节点会破坏性质 5（黑高不一致），可能需要多次调整。面试中一般只考插入操作，删除操作了解基本流程即可。

删除的基本流程

按照普通 BST 的规则删除节点（叶子节点直接删，只有一个孩子的节点用孩子替换，有两个孩子的节点用右子树最小节点替换）

如果删除的是红色节点，不需要调整，直接满足所有性质

如果删除的是黑色节点，会导致黑高不一致，需要进行平衡调整

删除调整的四种情况

删除黑色节点后，我们用cur指向替代节点，parent指向父节点，sibling指向兄弟节点。根据兄弟节点的颜色和位置，调整分为四种情况：

1.兄弟节点是红色

2.兄弟节点是黑色，且兄弟的两个孩子都是黑色

3.兄弟节点是黑色，兄弟的左孩子是红色，右孩子是黑色

4.兄弟节点是黑色，兄弟的右孩子是红色

这些情况的处理逻辑比较复杂，实际开发中我们直接使用 STL 的map/set即可，不需要自己实现删除操作。

四、红黑树 vs AVL 树：为什么 STL 选红黑树？

STL 选择红黑树的核心原因：

插入删除性能更稳定 ：红黑树的插入最多 2 次旋转，删除最多 3 次旋转，而 AVL 树删除可能需要 O (logn) 次旋转，在频繁插入删除的场景下，红黑树的性能更稳定。

实现更简单 ：红黑树用颜色规则代替高度维护，不需要每个节点存储高度，节省内存，实现也更简单。

性能足够好：虽然红黑树的查找常数比 AVL 树稍大，但 O (logn) 的时间复杂度已经足够优秀，对于绝大多数应用场景来说，性能差异可以忽略不计。

五、重点总结

1.红黑树的五大性质 ：必须一字不差背下来，这是所有问题的基础。

2.为什么新节点默认是红色？ ：插入红色只会破坏性质 4，只需要局部调整；插入黑色会破坏性质 3，需要全局调整。

3.插入平衡调整的三种情况 ：叔叔红→变色；叔叔黑且 LL/RR→单旋 + 变色；叔叔黑且 LR/RL→双旋 + 变色。

4.红黑树和 AVL 树的区别 ：平衡强度、旋转次数、性能、适用场景，重点说明为什么 STL 选红黑树。

5.红黑树的时间复杂度：O (logn)，因为最长路径不超过最短路径的 2 倍。

红黑树是 STL map/set的核心，也是校招面试的必考题。掌握了红黑树的自平衡机制，你就真正理解了平衡二叉搜索树的设计精髓。

本文属于 《C++ 进阶篇系统教程》第 6 篇

关注我，第一时间收到更新，不用自己零散找资料，跟着系列系统学，少走 90% 的弯路！