红黑树其实也简单

红黑树的概念

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

红黑树的性质

1. 根节点必须是黑色的。
2. 每个节点不是黑色就是红色。
3. 没有连续的红色节点。(如果一个节点是红色的，则它的两个孩子结点是黑色的)
4. 每条路径上的黑色节点的数目是相同的。
5. 所以的空结点都是黑色的。(所以空树也是红黑树)

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

当所有节点为黑色时，他是一个满二叉树！！它的所有路径都是最短路径。

他的最长路径一定会有红色节点：

红黑树节点的定义

// 节点的颜色
enum Colour
{
	RED,
	BLACK
};
// 红黑树节点的定义
template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left; // 节点的左孩子
	RBTreeNode<K,V>* _right;  // 节点的右孩子
	RBTreeNode<K, V>* _parent; // 节点的双亲(便于实现)
	pair<K, V> _kv;    //节点的值域
	enum Colour _col;  //节点的颜色

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED) //默认给红色
	{}
};

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？

答： 节点要是给黑色，插入之后会破环性质4，每条路径上的黑色节点的数目不相等了，我们很难维护这条性质，要是给红色，破坏性质3，这条性质容易维护，我们可以通过一些办法，使这棵树再一次成为红黑树。

红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：了解二叉搜索树看这里：二叉搜索树

1. 寻找应该插入的位置。
2. 保持红黑树的性质。

具体代码如下：

pair<Node*, bool> Insert(const pair<K, V>& kv)
	{
	// 第一步：寻找要插入的位置
		if (_root == nullptr) // 要是是空树，将要插入的节点变为根，并将颜色置为黑色
		{
			_root = new Node(kv);
			_root->_col = BLACK; //根节点为黑色
			return make_pair(_root, 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 make_pair(cur, false);
			}
		}
		// 走到这儿表示对应位置已找到
		// 准备插入
		cur = new Node(kv);//要插入节点默认是红色

		if (parent->_kv.first<kv.first) // 大就插在右边
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else                      // 小就插在左边
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
// 第二步： 维持红黑树的性质  （下面具体讲解，看图理解代码）
		Node* newNode = cur;
		// 两个连续节点为红色
		while (parent&&parent->_col == RED)
		{
			//一定会有grandfather节点，因为根节点必须是黑色
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				// 情况一：uncle存在且为红
				if (uncle&&uncle->_col == RED)
				{
					// 将parent和uncle都变成黑色，greadfather变成红色
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;
					// 继续往上处理
					cur = grandfather;
					parent = grandfather->_parent;
				}
				else // 情况2+3：u不存在或者存在且为黑(存在且为黑是由情况一变化而来)
				{
					//       g
					//    p
					//  c
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						 //      g
						//    p
						//      c
						RotateL(parent);
						RotateR(grandfather);
						grandfather->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}
			}
			else //  grandfather ->_right==parent
			{
				Node* uncle = grandfather->_left;
				// 情况一：uncle存在且为红
				if (uncle&&uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;

				}
				else //uncle不存在或存在且为黑
				{
					// g
					//   p
					//     c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//   g
						//     p
						//  c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(newNode, true);
	}

维护红黑树的性质：

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；

但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

• 情况一：cur为红，p为红，g为黑，u存在且为红
  
• 情况二： cur为红，p为红，g为黑，u不存在/u为黑
• 此时维护红黑树的性质就需要对其进行旋转了，旋转完成后，将某些节点的颜色变换即可
• 具体了解旋转请参考上文 AVL树 ------旋转介绍很详细。

1. 单旋情况（这里只展示右单旋,左单旋参考右单旋）
   
2. 双旋情况 ：(这里只展示左右双旋)
   
   
   

此时拿着图在和上面的代码对应着看，是不是特别清楚呢！！

红黑树的验证

红黑树的检测分为两步：

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

	//中序遍历
	void _Inorder(Node*root)
		{
			if (root == nullptr)
				return;
			_Inorder(root->_left);
			cout << root->_kv.first << " ";
			_Inorder(root->_right);
		}
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	// 检查是否满足红黑树的性质
	bool IsBalance()
	{
		if (_root&&_root->_col == RED)
		{
			cout << "违反规则一：根节点是红色的"<<endl;
			return false;
		}
		// 统计出左路的黑色节点的个数,用于对比
		int trueNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++trueNum;
			}
			cur = cur->_left;
		}
		int blackNum = 0;
		return _CheckRedCol(_root) && _CheckBlackNum(_root, blackNum, trueNum);

	}
		//是否有连续的红色节点
		bool _CheckRedCol(Node*root)
		{
			if (root == nullptr)
				return true;
			//这里判断节点与他的父节点
			if (root->_col == RED)
			{
				Node* parent = root->_parent;
				if (parent&&parent->_col == RED)
				{
					cout << "违反规则2：存在连续的红色节点"<<endl;
					return false;
				}
			}
			return _CheckRedCol(root->_left) && _CheckRedCol(root->_right);
		}
		// 检查各路的黑色节点个数
		bool _CheckBlackNum(Node*root, int blackNum, int trueNum)
		{
			if (root == nullptr)
				return trueNum == blackNum;

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

			return  _CheckBlackNum(root->_left, blackNum, trueNum) && \
				_CheckBlackNum(root->_right, blackNum, trueNum);
		}
//###############################
void testRBTree()
{
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	RBTree<int, int> t;
	for (auto&e : a)
	{
		t.Insert(make_pair(e, e));
	}
	t.Inorder();
	cout << t.IsBalance() << endl;
}

结果展示：

红黑树与AVL树的比较

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

红黑树的应用

1. C++ STL库 – map/set、mutil_map/mutil_set
2. Java 库
3. linux内核
4. 其他一些库