红黑树基本代码实现

---

一、什么是红黑树

1.1 红黑树的概念

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

1.2 红黑树的性质

1. 每个结点不是红色就是黑色。
2. 根节点是黑色的。
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的。
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点。
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)。

对性质3和性质4，可以换一种说法

• 没有连续的红结点
• 每条路径（根节点到空节点的路径）上的黑结点数量相同

为什么满足这几条性质就可以保证最长路径不超过最短路径的两倍呢？
这其中主要就是性质3和性质4，性质3限制了红结点的数量，由于根节点是黑结点，那么一条路径上红结点数量小于等于黑结点的数量，所以最短路径的下界全是黑结点，全长路径的上界为黑红相间，即全黑的两倍长度。

二、红黑树的实现

2.1 红黑树的结点定义

// 定义枚举常量表示颜色
enum Color
{
	RED, BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	pair<K, V> _kv;

	Color _col;

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

template<class K, class V>
class RBTree
{
	typedef	RBTreeNode<K, V> Node;
public:
	RBTree()
		:_root(nullptr)
	{}

private:
	Node* _root;
};

2.2 红黑树的插入

首先按二叉搜索树的规则插入结点，然后再根据红黑树的性质来调整。
默认插入的新节点为红色比红色好。为什么呢？

1. 黑色会违反性质4，改变了路径上黑色节点的数量，需要对每条路径都调整，这样很麻烦。
2. 插入红色会违反性质3，但并不是每次都违反，也有很多时候是可以直接插入的，而且违反性质3容易修正，只用修正到根节点的路径，修正时间复杂度为树的高度级别，很小。

因为默认插入颜色是红色，当新增结点的父节点是黑色的时候不用修改，但父节点是红色结点的时候违反了性质3，需要往上修正。

2.2.1 插入结点不满足性质的情况

当父节点为黑色时，正常插入；为红色时违反性质3，需要分类修改

约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点
情况一： cur为红，p为红，g为黑，u存在且为红

此时违反性质3，需要将父节点变为黑色，为了不影响路径上黑色结点的数量，将祖父结点变为红色，同时将叔叔结点变为黑色。

本次变色结束后，还要向上继续调整，将祖父结点当做当前结点，看是否满足性质，当然也许是其他不满足的情况，后面讨论。

情况二： cur为红，p为红，g为黑，u不存在/u为黑
u的情况有两种

1. 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4:每条路径黑色节点个数相同。
2. 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。

此时不能改变父节点和祖父结点的颜色，因为如果改变颜色，叔叔路径上的黑色结点数将会变少。所以就需要用到旋转，根据不同情况又可以分为单旋和双旋。

1. g, p, cur在同一条线上 — 单旋

p为g的左孩子，cur为p的左孩子，则进行右单旋转
相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转
变色：p、g变色–p变黑，g变红

2. g, p, cur 不在一条直线上 — 双旋

p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；
相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
变色：cur变黑，g变红

2.2.2 代码实现

	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 (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else return false;
		}
		cur = new Node(kv);
		cur->_col = RED; // 默认插入为红色
		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		// 如果出现错误需要调整平衡
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent, *uncle;
			if (parent == grandfather->_left)
			{
				uncle = grandfather->_right;
				// 第一种情况，u存在且为红，变色加向上调整
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// 第二种情况，旋转加变色
					
					//单旋     g
					//       p  
					//   cur
					if (cur == parent->_left)
					{
						// 右单旋
						RotateR(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						//双旋      g
						//       p  
						//          cur
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					//单旋     g
					//            p  
					//              cur
					if (cur == parent->_right)
					{
						// 左单旋
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						//双旋    g
						//            p  
						//        cur
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		// 统一处理根
		_root->_col = BLACK;
		return true;
	}

2.3 红黑树的验证

1. 验证是否为二叉搜索树 – 中序遍历是否有序
2. 验证红黑树的定义条件 – 验证每条性质

验证特殊数插入后，可使用随机数插入进行验证

void InOrder()
	{
		_InOrder(_root);
	}

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

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

bool IsBalance()
	{
		// 验证根节点
		if (_root && _root->_col == RED)
		{
			cout << " 根节点是红结点" << endl;
			return false;
		}

		// 选取最左边路径上黑色结点的数量作为基准值，用来比较其他路径黑色结点数量是否相等
		int benchmark = 0;
		Node* tmp = _root;
		while (tmp != nullptr)
		{
			if(tmp->_col == BLACK)
				benchmark++;
			tmp = tmp->_left;
		}
		int blackNum = 0; // 每个路径上黑色结点的数量，利用函数递归调用的栈，每个路径独有一个该值
		return _IsBalance(_root, benchmark, blackNum);
	}
	bool _IsBalance(Node* root, int benchmark, int blackNum)
	{
		if (root == nullptr)
		{
			// 检查性质4
			if (benchmark != blackNum)
			{
				cout << "路径黑色结点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK) blackNum++;
		// 检查性质3
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有两个连续的红结点" << endl;
			return false;
		}

		return _IsBalance(root->_left, benchmark, blackNum)
			&& _IsBalance(root->_right, benchmark, blackNum);
	}

测试代码

void TestRBTree()
{
	RBTree<int, int> t;
	vector<int> v;
	srand(time(0));
	int N = 100000;
	for (int i = 0; i < N; ++i)
	{
		v.push_back(rand());
		//v.push_back(i);
	}
	//int a[] = { 5,4,3,2,1,0 };
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
		if (!t.IsBalance())
		{
			cout << "Insert" << e << endl;
		}
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
}