devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

高级数据结构——红黑树_十个节点的最高红黑树

作者：你好赵伟 | 2024-06-20 05:38:59

赞

踩

十个节点的最高红黑树

目录

1. 红黑树的概念

2. 红黑树的性质

3.  红黑树

6. 红黑树的验证

7. 红黑树的删除

8. 红黑树与AVL数的比较

9. 红黑树的应用

10. 完整代码

10.1 RBTree.h

10.2 test.cpp

1. 红黑树的概念

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

 同是二叉搜索平衡树，但是AVL树控制的比红黑树严格的多，AVL树要是每个节点的平衡因子绝对值不超过1，就会导致不断的去旋转调整，付出相对较高的代价，而这里红黑树更像是一种近似平衡，条件没有这么苛刻。

如下一棵树，站在红黑树的角度看是平衡的，站在AVL树的角度看就是不平衡的，需要旋转调整：

 但是从搜索效率的角度看AVL树还是好一点，因为它的平衡标准高，就导致其更加平衡，相同数量的节点情况下AVL树的高度会更低，加上存100w个数据，AVL树大概有20层（log100w），而红黑树最坏就能达到40层，显然AVL树的搜索效率高。但是在内存里找20次和找40次没有什么区别，因为CPU足够的快，这里简单提一下。

2. 红黑树的性质

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

根据这些规则，红黑树是如何保证最长路径不超过最短路径的2倍的呢？

首先我们根据规则分析得知，我们假设一条路径的黑色节点的个数为N个，则最长路径和最短路径的情况如下：

  • 最短路径：全黑

  • 最长路径：一黑一红间隔

 而这里一黑一红间隔的原因在于红黑树不允许出现连续的红节点，为了能最大程度的保证最长节点数，唯有一黑一红间隔的方式才能达到最长，综上当黑节点个数固定为N时，最短路径节点个数为N，最长路径节点个数为2N。

3.  红黑树

这里节点的实现相较于AVL树我们依旧是创建成KV模型、三叉链结构，唯一有所改变的是这里要通过枚举的方式把红色和黑色定义好，并在节点类内部定义变量_col表示节点颜色，最后记得写上构造函数。

  1. enum Colour
  2. {
  3. 	Red,
  4. 	Black,
  5. };
  6. //节点类
  7. template <class K, class V>
  8. struct RBTreeNode
  9. {
  10. 	//三叉链结构
  11. 	RBTreeNode<K, V>* _left;
  12. 	RBTreeNode<K, V>* _right;
  13. 	RBTreeNode<K, V>* _parent;
  14. 	//存储的键值对
  15. 	pair<K, V> _kv;
  16. 	//节点的颜色
  17. 	Colour _col;
  18. 	//构造函数
  19. 	RBTreeNode(const pair<K, V>& kv)
  20. 		:_left(nullptr)
  21. 		, _right(nullptr)
  22. 		, _parent(nullptr)
  23. 		, _kv(kv)
  24. 		, _col(Red)
  25. 	{}
  26. };

为什么插入的节点在构造函数这里要处理成红色？

  1. 如果处理成黑色，则一定导致新插入节点的那条路径多出一个黑色节点，不再满足各个路径黑色节点个数相同的性质，一定破坏性质4，此时很难维护。
  2. 如果处理成红色，则可能父亲节点也是红色，此时就出现了连续的红色节点，破坏性质3，不过此时我们向上调整即可，但如果父亲节点是黑色，那就无需操作了，不违反任何性质。

综合利弊，插入黑色节点一定会破坏性质4，而插入红色节点可能破坏性质3，因此处理成红色为宜。

5. 红黑树的插入操作

红黑树的插入操作主要分为这几大步骤：

  • 1、一开始为空树，直接new新节点；
  • 2、一开始非空树，寻找插入的合适位置；
  • 3、找到插入的合适位置后，进行父亲与孩子的双向链接；
  • 4、检测新节点插入后，红黑树的性质是否造到破坏。

接下来对其进行逐个分析：

  • 1、一开始为空树，直接new新节点：

因为树为空的，所以直接new一个新插入的节点，将其作为根_root即可，接着更新颜色_col为黑色。

  • 2、一开始非空树，寻找插入的合适位置：

这里和二叉搜索树的寻找合适的插入位置的思想一样，都要遵循以下几步：

  1. 插入的值 > 节点的值，更新到右子树查找
  2. 插入的值 < 节点的值，更新到左子树查找
  3. 插入的值 = 节点的值，数据冗余插入失败，返回false

当循环结束的时候，就说明已经找到插入的合适位置，即可进行下一步链接。

  • 3、找到插入的合适位置后，进行父亲与孩子的双向链接：

注意这里节点的构成为三叉链，因此最后链接后端孩子和父亲是双向链接，具体操作如下：

  1. 插入的值 > 父亲的值，把插入的值链接在父亲的右边
  2. 插入的值 < 父亲的值，把插入的值链接在父亲的左边
  3. 因为是三叉连，插入后记得双向链接（孩子链接父亲）

走到这，说明节点已经插入完毕，接下来就要对红黑树的颜色进行调整了

  • 4、检测新节点插入后，红黑树的性质是否造到破坏：

不是所有的情况都是需要进行调整的，当插入节点的父亲为黑色（新节点的默认颜色是红色），那么就不需要进行调整，因为没有破坏红黑树的任何一条性质。

只有当插入节点的父亲为红色时（新节点的默认颜色也是是红色），才需要进行调整，因为此时插入的节点和父亲都是红色节点，但是红黑树不允许出现连续的红色节点，此时就要进行调整。

注意这里既然插入节点cur的父亲p是红色，那么根据红黑树的性质（根结点是黑色的），其父亲的父亲g也就是祖父必然存在且一定是黑色，那么其父亲的兄弟节点u（可能不存在）也就是新插入节点cur的叔叔。因此我们约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点。

这里调整的办法主要是看叔叔节点的颜色如何，叔叔节点的不同，会导致三种不同的情况需要调整：

  • 情况一：cur为红，p为红，g为黑，u存在且为红
  • 情况二：cur为红，p为红，g为黑，u不存在
  • 情况三：cur为红，p为红，g为黑，u存在且为黑

接下来分别进行讨论：

  • 情况一：cur为红，p为红，g为黑，u存在且为红

为了避免出现连续的红色节点，我们可以把父节点p变黑，但是为了保证每条路径的黑色节点个数相同，我们需要把祖父节g点变红（不影响其它路径黑节点的个数），再把叔叔节点u变黑。

调整并未结束，此时祖父节点g为红色，但是如果这棵树本就是一颗完整的树呢？也就是g为根节点，那么只需要把节点g变成黑色即可。

如果这棵树是一棵树的子树，那么刚好把祖父节点g作为新插入的节点cur向上继续调整（继续判断父亲、叔叔如何……），直至调整结束。

补充：情况一不关心左右关系，只变色不旋转，所以 p、u是g的左或右是无所谓的，cur是p的左或右也是无所谓的。

接下来分析情况2：

  • 情况二：cur为红，p为红，g为黑，u不存在

 如果节点u不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。

此时就是一个很经典的右单旋结构（新节点插入较高左子树的左侧）我们可以先对其进行一个右单旋，再来更新颜色。具体步骤如下：

  1. 让祖父g变成父亲p的右子树。
  2. 父亲p作为根节点。
  3. 更新父亲节点p为黑色。
  4. 更新祖父g为红色。

  • 补充：

如若p为g的右孩子，cur为p的右孩子，则针对p做左单旋转，示例：

如若祖孙三代的关系是折线（cur、parent、grandfather这三个结点为一条折现），则我们需要先进行双旋操作，再进行颜色调整，颜色调整后这棵被旋转子树的根是黑色的，因此无需继续往上进行处理。示例：

 综上：

  1. p为g的左，cur为p的左，则进行右单旋 + p变黑，g变红；
  2. p为g的右，cur为p的右，则进行左单旋 + p变黑，g变红；
  3. p是g的左，cur是p的右，则进行左右双旋 + cur变黑， g变红；
  4. p是g的右，cur是p的左，则进行右左双旋 + cur变黑， g变红。

下面进入情况三

  • 情况三：cur为红，p为红，g为黑，u存在且为黑

此情况绝非单独存在，绝不可能是真的新节点cur插入，然后还会出现p为红，g为黑，u存在且为黑的情况，如果存在，那么只能说明先前插入节点或者构造函数就有问题，因为插入前就不符合红黑树的性质啊（每个路径的黑节点个数均相同）。

既然情况三出现了，那么一定是合理的，它就是建立在情况一的基础上继续往上调整从而出现的一种特殊情况，具体咱就是画图演示：

 此时就是很明显的一个情况3了，cur为红，pp为红，gg为黑，u存在且为黑，由此证明，情况三是通过情况一向上继续调整演化出来的。并且此新节点一定是从p和x任意一颗左右子树插入或演化上来的，才引发后续的cur从黑变红。

此时就是一个很经典的右单旋结构（cur在较高左子树的左侧）我们可以先对其进行一个右单旋，再来更新颜色。具体步骤如下：

  1. 让p的右子树变成g的左子树；
  2. 让p变成根节点位置；
  3. p的右子树指向g；
  4. 更新p的颜色为黑色；
  5. 更新g的颜色为红色。

 补充：

如若p为g的右孩子，cur为p的右孩子，则进行左单旋 + 调色，示例：

若祖孙三代的关系是折现（cur、parent、grandfather这三个结点为一条折线），则我们需要先进行双旋操作，再进行颜色调整，颜色调整后这棵被旋转子树的根是黑色的，因此无需继续往上进行处理。示例：

综上：

  • p为g的左，cur为p的左，则进行右单旋 + p变黑，g变红;
  • p为g的右，cur为p的右，则进行左单旋 + p变黑，g变红;
  • p是g的左，cur是p的右，则进行左右双旋 + cur变黑， g变红;
  • p是g的右，cur是p的左，则进行右左双旋 + cur变黑， g变红.

情况二和情况三旋转 + 变色后，这颗子树不违反红黑树规则，相比插入前，且黑色节点的数量不变，不会影响上层，处理结束了。

代码如下：

  1. bool Insert(const pair<K, V>& kv)
  2. {
  3. 	//1、一开始为空树，直接new新节点
  4. 	if (_root == nullptr)
  5. 	{
  6. 		_root = new Node(kv);
  7. 		_root->_col = Black;//新插入的节点处理成黑色
  8. 		return true;
  9. 	}
  10. 	//2、寻找插入的合适位置
  11. 	Node* cur = _root;
  12. 	Node* parent = nullptr;
  13. 	while (cur)
  14. 	{
  15. 		if (cur->_kv.first < kv.first)
  16. 		{
  17. 			parent = cur;
  18. 			cur = cur->_right;//插入的值 > 节点的值，更新到右子树查找
  19. 		}
  20. 		else if (cur->_kv.first > kv.first)
  21. 		{
  22. 			parent = cur;
  23. 			cur = cur->_left;//插入的值 < 节点的值，更新到左子树查找
  24. 		}
  25. 		else
  26. 		{
  27. 			return false;//插入的值 = 节点的值，数据冗余插入失败，返回false
  28. 		}
  29. 	}
  30. 	//3、找到了插入的位置，进行父亲与插入节点的链接
  31. 	cur = new Node(kv);
  32. 	cur->_col = Red;//插入的节点处理成红色
  33. 	if (parent->_kv.first < kv.first)
  34. 	{
  35. 		parent->_right = cur;//插入的值 > 父亲的值，链接在父亲的右边
  36. 	}
  37. 	else
  38. 	{
  39. 		parent->_left = cur;//插入的值 < 父亲的值，链接在父亲的左边
  40. 	}
  41. 	cur->_parent = parent;//三叉链，要双向链接
  42.  
  43. //4、检测新节点插入后，红黑树的性质是否造到破坏
  44. 	while (parent && parent->_col == Red)//存在连续的红色节点
  45. 	{
  46. 		Node* grandfather = parent->_parent;
  47. 		assert(grandfather);
  48. 		//先确保叔叔的位置
  49. 		if (grandfather->_left == parent)
  50. 		{
  51. 			Node* uncle = grandfather->_right;
  52. 			//情况一：cur为红，p为红，g为黑，u存在且为红
  53. 			if (uncle && uncle->_col == Red)
  54. 			{
  55. 				//变色
  56. 				parent->_col = uncle->_col = Black;
  57. 				grandfather->_col = Red;
  58. 				//继续往上处理
  59. 				cur = grandfather;
  60. 				parent = cur->_parent;
  61. 			}
  62. 			//情况二+情况三：叔叔不存在，或者叔叔存在且为黑
  63. 			else
  64. 			{
  65. 				if (cur == parent->_left)//p为g的左，cur为p的左，则进行右单旋 + p变黑，g变红
  66. 				{
  67. 					//		  g
  68. 					//     p
  69. 					// cur
  70. 					RotateR(grandfather);
  71. 					parent->_col = Black;
  72. 					grandfather->_col = Red;
  73. 				}
  74. 				else//p是g的左，cur是p的右，则进行左右双旋 + cur变黑， g变红
  75. 				{
  76. 					//		  g
  77. 					//	 p
  78. 					//	     cur
  79. 					RotateLR(grandfather);
  80. 					cur->_col = Black;
  81. 					grandfather->_col = Red;
  82. 				}
  83. 				break;
  84. 			}
  85. 		}
  86. 		else//grandfather->_right == parent
  87. 		{
  88. 			Node* uncle = grandfather->_left;
  89. 			//情况一：cur为红，p为红，g为黑，u存在且为红
  90. 			if (uncle && uncle->_col == Red)
  91. 			{
  92. 				//变色
  93. 				parent->_col = uncle->_col = Black;
  94. 				grandfather->_col = Red;
  95. 				//继续往上处理
  96. 				cur = grandfather;
  97. 				parent = cur->_parent;
  98. 			}
  99. 			//情况二+情况三：叔叔不存在，或者叔叔存在且为黑
  100. 			else
  101. 			{
  102. 				if (cur == parent->_right)//p为g的右，cur为p的右，则进行左单旋 + p变黑，g变红
  103. 				{
  104. 					//	g
  105. 					//	   p
  106. 					//	     cur
  107. 					RotateL(grandfather);
  108. 					parent->_col = Black;
  109. 					grandfather->_col = Red;
  110. 				}
  111. 				else//p是g的右，cur是p的左，则进行右左双旋 + cur变黑， g变红
  112. 				{
  113. 					//   g
  114. 					//	      p
  115. 					//	cur
  116. 					RotateRL(grandfather);
  117. 					cur->_col = Black;
  118. 					grandfather->_col = Red;
  119. 				}
  120. 				break;
  121. 			}
  122. 		}
  123. 	}
  124. 	_root->_col = Black;//暴力处理把根变成黑色
  125. 	return true;
  126. }
  127. //1、左单旋
  128. void RotateL(Node* parent)
  129. {
  130. 	Node* subR = parent->_right;
  131. 	Node* subRL = subR->_left;
  132. 	Node* ppNode = parent->_parent;//提前保持parent的父亲
  133. 	//1、建立parent和subRL之间的关系
  134. 	parent->_right = subRL;
  135. 	if (subRL)//防止subRL为空
  136. 	{
  137. 		subRL->_parent = parent;
  138. 	}
  139. 	//2、建立subR和parent之间的关系
  140. 	subR->_left = parent;
  141. 	parent->_parent = subR;
  142. 	//3、建立ppNode和subR之间的关系
  143. 	if (parent == _root)
  144. 	{
  145. 		_root = subR;
  146. 		_root->_parent = nullptr;
  147. 	}
  148. 	else
  149. 	{
  150. 		if (parent == ppNode->_left)
  151. 		{
  152. 			ppNode->_left = subR;
  153. 		}
  154. 		else
  155. 		{
  156. 			ppNode->_right = subR;
  157. 		}
  158. 		subR->_parent = ppNode;//三叉链双向链接关系
  159. 	}
  160. }
  161. //2、右单旋
  162. void RotateR(Node* parent)
  163. {
  164. 	Node* subL = parent->_left;
  165. 	Node* subLR = subL->_right;
  166. 	Node* ppNode = parent->_parent;
  167. 	//1、建立parent和subLR之间的关系
  168. 	parent->_left = subLR;
  169. 	if (subLR)
  170. 	{
  171. 		subLR->_parent = parent;
  172. 	}
  173. 	//2、建立subL和parent之间的关系
  174. 	subL->_right = parent;
  175. 	parent->_parent = subL;
  176. 	//3、建立ppNode和subL的关系
  177. 	if (parent == _root)
  178. 	{
  179. 		_root = subL;
  180. 		_root->_parent = nullptr;
  181. 	}
  182. 	else
  183. 	{
  184. 		if (parent == ppNode->_left)
  185. 		{
  186. 			ppNode->_left = subL;
  187. 		}
  188. 		else
  189. 		{
  190. 			ppNode->_right = subL;
  191. 		}
  192. 		subL->_parent = ppNode;//三叉链双向关系
  193. 	}
  194. }
  195. //3、左右双旋
  196. void RotateLR(Node* parent)
  197. {
  198. 	RotateL(parent->_left);
  199. 	RotateR(parent);
  200. }
  201. //4、右左双旋
  202. void RotateRL(Node* parent)
  203. {
  204. 	RotateR(parent->_right);
  205. 	RotateL(parent);
  206. }

6. 红黑树的验证

红黑树的验证主要分为两大步骤：

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

接下来分别演示：

  • 1、检测其是否满足二叉搜索树(中序遍历是否为有序序列)：

这里只需要递归写一个中序遍历，并判断测试用例的结果是否为一个有序序列即可判断二叉搜索树：

  1. //验证是否为一颗搜索二叉树
  2. void InOrder()
  3. {
  4. 	_InOrder(_root);//调用中序遍历子树
  5. 	cout << endl;
  6. }
  7. //中序遍历的子树
  8. void _InOrder(Node* root)
  9. {
  10. 	if (root == nullptr)
  11. 		return;
  12. 	_InOrder(root->_left);
  13. 	cout << root->_kv.first << " ";
  14. 	_InOrder(root->_right);
  15. }
  • 2、检测其是否满足红黑树的性质：

这里只要判断是否满足红黑树的5大规则即可，具体操作如下：

  • 1、根节点是否为黑色；
  • 2、任意一条路径黑色节点数是否相同（递归每一条和确定的一条比较是否相同）；
  • 3、递归检测是否违反性质三从而出现连续的红节点。
  1. bool IsBalanceTree()
  2. {
  3. 	Node* pRoot = _root;
  4. 	// 空树也是红黑树
  5. 	if (pRoot == nullptr)
  6. 		return true;
  7. 	// 检测根节点是否满足情况
  8. 	if (pRoot->_col != Black)
  9. 	{
  10. 		cout << "违反红黑树性质二：根节点必须为黑色" << endl;
  11. 		return false;
  12. 	}
  13. 	// 获取任意一条路径中黑色节点的个数-->拿最左路径作为比较基准值
  14. 	size_t blackCount = 0;
  15. 	Node* pCur = pRoot;
  16. 	while (pCur)
  17. 	{
  18. 		if (pCur->_col == Black)
  19. 			blackCount++;
  20. 		pCur = pCur->_left;
  21. 	}
  22. 	// 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
  23. 	size_t k = 0;
  24. 	return _IsValidRBTree(pRoot, k, blackCount);
  25. }
  26. bool _IsValidRBTree(Node* pRoot, size_t k, const size_t blackCount)
  27. {
  28. 	//走到null之后，判断k和black是否相等
  29. 	if (pRoot == nullptr)
  30. 	{
  31. 		if (k != blackCount)
  32. 		{
  33. 			cout << "违反性质四：每条路径中黑色节点的个数必须相同" << endl;
  34. 			return false;
  35. 		}
  36. 		return true;
  37. 	}
  38. 	// 统计黑色节点的个数
  39. 	if (pRoot->_col == Black)
  40. 		k++;
  41. 	// 检测当前节点与其双亲是否都为红色
  42. 	Node* pParent = pRoot->_parent;
  43. 	if (pParent && pParent->_col == Red && pRoot->_col == Red)
  44. 	{
  45. 		cout << "违反性质三：没有连在一起的红色节点，而这里出现了" << endl;
  46. 		return false;
  47. 	}
  48. 	return _IsValidRBTree(pRoot->_left, k, blackCount) && _IsValidRBTree(pRoot->_right, k, blackCount);
  49. }

7. 红黑树的删除

红黑树的删除这里和AVL树一样就不做过多演示了，具体可参考《算法导论》或者《STL源码剖析》。大佬博文：红黑树插入删除操作

8. 红黑树与AVL数的比较

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

9. 红黑树的应用

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

10. 完整代码

10.1 RBTree.h

  1. #pragma once
  2. #include<iostream>
  3. #include<queue>
  4. #include<vector>
  5. #include<assert.h>
  6. using namespace std;
  7. enum Colour
  8. {
  9. 	Red,
  10. 	Black,
  11. };
  12. //节点类
  13. template <class K, class V>
  14. struct RBTreeNode
  15. {
  16. 	//三叉链结构
  17. 	RBTreeNode<K, V>* _left;
  18. 	RBTreeNode<K, V>* _right;
  19. 	RBTreeNode<K, V>* _parent;
  20. 	//存储的键值对
  21. 	pair<K, V> _kv;
  22. 	//节点的颜色
  23. 	Colour _col;
  24. 	//构造函数
  25. 	RBTreeNode(const pair<K, V>& kv)
  26. 		:_left(nullptr)
  27. 		, _right(nullptr)
  28. 		, _parent(nullptr)
  29. 		, _kv(kv)
  30. 		, _col(Red)
  31. 	{}
  32. };
  33. //红黑树的类
  34. template <class K, class V>
  35. class RBTree
  36. {
  37. 	typedef RBTreeNode<K, V> Node;
  38. public:
  39. 	bool Insert(const pair<K, V>& kv)
  40. 	{
  41. 	//1、一开始为空树，直接new新节点
  42. 		if (_root == nullptr)
  43. 		{
  44. 			_root = new Node(kv);
  45. 			_root->_col = Black;//新插入的节点处理成黑色
  46. 			return true;
  47. 		}
  48. 	//2、寻找插入的合适位置
  49. 		Node* cur = _root;
  50. 		Node* parent = nullptr;
  51. 		while (cur)
  52. 		{
  53. 			if (cur->_kv.first < kv.first)
  54. 			{
  55. 				parent = cur;
  56. 				cur = cur->_right;//插入的值 > 节点的值，更新到右子树查找
  57. 			}
  58. 			else if (cur->_kv.first > kv.first)
  59. 			{
  60. 				parent = cur;
  61. 				cur = cur->_left;//插入的值 < 节点的值，更新到左子树查找
  62. 			}
  63. 			else
  64. 			{
  65. 				return false;//插入的值 = 节点的值，数据冗余插入失败，返回false
  66. 			}
  67. 		}
  68. 	//3、找到了插入的位置，进行父亲与插入节点的链接
  69. 		cur = new Node(kv);
  70. 		cur->_col = Red;//插入的节点处理成红色
  71. 		if (parent->_kv.first < kv.first)
  72. 		{
  73. 			parent->_right = cur;//插入的值 > 父亲的值，链接在父亲的右边
  74. 		}
  75. 		else
  76. 		{
  77. 			parent->_left = cur;//插入的值 < 父亲的值，链接在父亲的左边
  78. 		}
  79. 		cur->_parent = parent;//三叉链，要双向链接
  80.  
  81. 	//4、检测新节点插入后，红黑树的性质是否造到破坏
  82. 		while (parent && parent->_col == Red)//存在连续的红色节点
  83. 		{
  84. 			Node* grandfather = parent->_parent;
  85. 			assert(grandfather);
  86. 			//先确保叔叔的位置
  87. 			if (grandfather->_left == parent)
  88. 			{
  89. 				Node* uncle = grandfather->_right;
  90. 				//情况一：cur为红，p为红，g为黑，u存在且为红
  91. 				if (uncle && uncle->_col == Red)
  92. 				{
  93. 					//变色
  94. 					parent->_col = uncle->_col = Black;
  95. 					grandfather->_col = Red;
  96. 					//继续往上处理
  97. 					cur = grandfather;
  98. 					parent = cur->_parent;
  99. 				}
  100. 				//情况二+情况三：叔叔不存在，或者叔叔存在且为黑
  101. 				else
  102. 				{
  103. 					if (cur == parent->_left)//p为g的左，cur为p的左，则进行右单旋 + p变黑，g变红
  104. 					{
  105. 						//		  g
  106. 						//     p
  107. 						// cur
  108. 						RotateR(grandfather);
  109. 						parent->_col = Black;
  110. 						grandfather->_col = Red;
  111. 					}
  112. 					else//p是g的左，cur是p的右，则进行左右双旋 + cur变黑， g变红
  113. 					{
  114. 						//		  g
  115. 						//	 p
  116. 						//	     cur
  117. 						RotateLR(grandfather); 
  118. 						cur->_col = Black;
  119. 						grandfather->_col = Red;
  120. 					}
  121. 					break;
  122. 				}
  123. 			}
  124. 			else//grandfather->_right == parent
  125. 			{
  126. 				Node* uncle = grandfather->_left;
  127. 				//情况一：cur为红，p为红，g为黑，u存在且为红
  128. 				if (uncle && uncle->_col == Red)
  129. 				{
  130. 					//变色
  131. 					parent->_col = uncle->_col = Black;
  132. 					grandfather->_col = Red;
  133. 					//继续往上处理
  134. 					cur = grandfather;
  135. 					parent = cur->_parent;
  136. 				}
  137. 				//情况二+情况三：叔叔不存在，或者叔叔存在且为黑
  138. 				else
  139. 				{
  140. 					if (cur == parent->_right)//p为g的右，cur为p的右，则进行左单旋 + p变黑，g变红
  141. 					{
  142. 						//	g
  143. 						//	   p
  144. 						//	     cur
  145. 						RotateL(grandfather);
  146. 						parent->_col = Black;
  147. 						grandfather->_col = Red;
  148. 					}
  149. 					else//p是g的右，cur是p的左，则进行右左双旋 + cur变黑， g变红
  150. 					{
  151. 						//   g
  152. 						//	      p
  153. 						//	cur
  154. 						RotateRL(grandfather); 
  155. 						cur->_col = Black;
  156. 						grandfather->_col = Red;
  157. 					}
  158. 					break;
  159. 				}
  160. 			}
  161. 		}
  162. 		_root->_col = Black;//暴力处理把根变成黑色
  163. 		return true;
  164. 	}
  165. //验证是否为一颗搜索二叉树
  166. 	void InOrder()
  167. 	{
  168. 		_InOrder(_root);//调用中序遍历子树
  169. 		cout << endl;
  170. 	}
  171. //验证是否为红黑树
  172. 	bool IsBalanceTree()
  173. 	{
  174. 		Node* pRoot = _root;
  175. 		// 空树也是红黑树
  176. 		if (pRoot == nullptr)
  177. 			return true;
  178. 		// 检测根节点是否满足情况
  179. 		if (pRoot->_col != Black)
  180. 		{
  181. 			cout << "违反红黑树性质二：根节点必须为黑色" << endl;
  182. 			return false;
  183. 		}
  184. 		// 获取任意一条路径中黑色节点的个数-->拿最左路径作为比较基准值
  185. 		size_t blackCount = 0;
  186. 		Node* pCur = pRoot;
  187. 		while (pCur)
  188. 		{
  189. 			if (pCur->_col == Black )
  190. 				blackCount++;
  191. 			pCur = pCur->_left;
  192. 		}
  193. 		// 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
  194. 		size_t k = 0;
  195. 		return _IsValidRBTree(pRoot, k, blackCount);
  196. 	}
  197.  
  198. //求一棵树的高度
  199. 	void Height()
  200. 	{
  201. 		cout << "最长路径：" << _maxHeight(_root) << endl;
  202. 		cout << "最短路径：" << _minHeight(_root) << endl;
  203. 	}
  204. private:
  205. 	//1、左单旋
  206. 	void RotateL(Node* parent)
  207. 	{
  208. 		Node* subR = parent->_right;
  209. 		Node* subRL = subR->_left;
  210. 		Node* ppNode = parent->_parent;//提前保持parent的父亲
  211. 		//1、建立parent和subRL之间的关系
  212. 		parent->_right = subRL;
  213. 		if (subRL)//防止subRL为空
  214. 		{
  215. 			subRL->_parent = parent;
  216. 		}
  217. 		//2、建立subR和parent之间的关系
  218. 		subR->_left = parent;
  219. 		parent->_parent = subR;
  220. 		//3、建立ppNode和subR之间的关系
  221. 		if (parent == _root)
  222. 		{
  223. 			_root = subR;
  224. 			_root->_parent = nullptr;
  225. 		}
  226. 		else
  227. 		{
  228. 			if (parent == ppNode->_left)
  229. 			{
  230. 				ppNode->_left = subR;
  231. 			}
  232. 			else
  233. 			{
  234. 				ppNode->_right = subR;
  235. 			}
  236. 			subR->_parent = ppNode;//三叉链双向链接关系
  237. 		}
  238. 	}
  239. 	//2、右单旋
  240. 	void RotateR(Node* parent)
  241. 	{
  242. 		Node* subL = parent->_left;
  243. 		Node* subLR = subL->_right;
  244. 		Node* ppNode = parent->_parent;
  245. 		//1、建立parent和subLR之间的关系
  246. 		parent->_left = subLR;
  247. 		if (subLR)
  248. 		{
  249. 			subLR->_parent = parent;
  250. 		}
  251. 		//2、建立subL和parent之间的关系
  252. 		subL->_right = parent;
  253. 		parent->_parent = subL;
  254. 		//3、建立ppNode和subL的关系
  255. 		if (parent == _root)
  256. 		{
  257. 			_root = subL;
  258. 			_root->_parent = nullptr;
  259. 		}
  260. 		else
  261. 		{
  262. 			if (parent == ppNode->_left)
  263. 			{
  264. 				ppNode->_left = subL;
  265. 			}
  266. 			else
  267. 			{
  268. 				ppNode->_right = subL;
  269. 			}
  270. 			subL->_parent = ppNode;//三叉链双向关系
  271. 		}
  272. 	}
  273. 	//3、左右双旋
  274. 	void RotateLR(Node* parent)
  275. 	{
  276. 		RotateL(parent->_left);
  277. 		RotateR(parent);
  278. 	}
  279.  
  280. 	//4、右左双旋
  281. 	void RotateRL(Node* parent)
  282. 	{
  283. 		RotateR(parent->_right);
  284. 		RotateL(parent);
  285. 	}
  286. //中序遍历的子树
  287. 	void _InOrder(Node* root)
  288. 	{
  289. 		if (root == nullptr)
  290. 			return;
  291.  
  292. 		_InOrder(root->_left);
  293. 		cout << root->_kv.first << " ";
  294. 		_InOrder(root->_right);
  295. 	}
  296. //求一棵树的最长路径的子树
  297. 	int _maxHeight(Node* root)
  298. 	{
  299. 		if (root == nullptr)
  300. 			return 0;
  301. 		int lh = _maxHeight(root->_left);
  302. 		int rh = _maxHeight(root->_right);
  303. 		return lh > rh ? lh + 1 : rh + 1;
  304. 	}
  305. //求一棵树的最短路径的子树
  306. 	int _minHeight(Node* root)
  307. 	{
  308. 		if (root == nullptr)
  309. 			return 0;
  310. 		int lh = _minHeight(root->_left);
  311. 		int rh = _minHeight(root->_right);
  312. 		return lh < rh ? lh + 1 : rh + 1;
  313. 	}
  314. //求是否满足红黑树性质的子树
  315. 	bool _IsValidRBTree(Node* pRoot, size_t k, const size_t blackCount)
  316. 	{
  317. 		//走到null之后，判断k和black是否相等
  318. 		if (pRoot == nullptr)
  319. 		{
  320. 			if (k != blackCount)
  321. 			{
  322. 				cout << "违反性质四：每条路径中黑色节点的个数必须相同" << endl;
  323. 				return false;
  324. 			}
  325. 			return true;
  326. 		}
  327. 		// 统计黑色节点的个数
  328. 		if (pRoot->_col == Black)
  329. 			k++;
  330. 		// 检测当前节点与其双亲是否都为红色
  331. 		Node* pParent = pRoot->_parent;
  332. 		if (pParent && pParent->_col == Red && pRoot->_col == Red)
  333. 		{
  334. 			cout << "违反性质三：没有连在一起的红色节点，而这里出现了" << endl;
  335. 			return false;
  336. 		}
  337. 		return _IsValidRBTree(pRoot->_left, k, blackCount) && _IsValidRBTree(pRoot->_right, k, blackCount);
  338. 	}
  339. public:
  340. 		//层序遍历（非必须）
  341. 	vector<vector<int>> levelOrder() {
  342. 		vector<vector<int>> vv;
  343. 		if (_root == nullptr)
  344. 			return vv;
  345. 		queue<Node*> q;
  346. 		int levelSize = 1;
  347. 		q.push(_root);
  348. 		while (!q.empty())
  349. 		{
  350. 			// levelSize控制一层一层出
  351. 			vector<int> levelV;
  352. 			while (levelSize--)
  353. 			{
  354. 				Node* front = q.front();
  355. 				q.pop();
  356. 				levelV.push_back(front->_kv.first);
  357. 				if (front->_left)
  358. 					q.push(front->_left);
  359.  
  360. 				if (front->_right)
  361. 					q.push(front->_right);
  362. 			}
  363. 			vv.push_back(levelV);
  364. 			for (auto e : levelV)
  365. 			{
  366. 				cout << e << " ";
  367. 			}
  368. 			cout << endl;
  369. 			// 上一层出完，下一层就都进队列
  370. 			levelSize = q.size();
  371. 		}
  372. 		return vv;
  373. 	}
  374.  
  375. private:
  376. 	Node* _root = nullptr;
  377. };

10.2 test.cpp

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"RBTree.h"
  3. void TestRBTree1()
  4. {
  5. 	//int a[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
  6. 	int a[] = { 30, 29, 28, 27, 26, 25, 24, 11, 8, 7, 6, 5, 4, 3, 2, 1 };
  7. 	RBTree<int, int> t;
  8. 	for (auto e : a)
  9. 	{
  10. 		t.Insert(make_pair(e, e));
  11. 	}
  12. 	t.levelOrder();
  13. 	t.InOrder();
  14. 	t.Height();
  15. }
  16.  
  17. void TestRBTree2()
  18. {
  19. 	const size_t N = 1024 * 1024;
  20. 	vector<int> v;
  21. 	v.reserve(N);
  22. 	srand(time(0));
  23. 	for (size_t i = 0; i < N; ++i)
  24. 	{
  25. 		//v.push_back(rand());
  26. 		v.push_back(i);
  27. 	}
  28.  
  29. 	RBTree<int, int> t;
  30. 	for (auto e : v)
  31. 	{
  32. 		t.Insert(make_pair(e, e));
  33. 	}
  34.  
  35. 	//t.levelOrder();
  36. 	//cout << endl;
  37. 	cout << "Ƿƽ? " << t.IsBalanceTree() << endl;
  38. 	t.Height();
  39.  
  40. 	//t.InOrder();
  41. }
  42. int main()
  43. {
  44. 	//TestRBTree1();
  45. 	TestRBTree2();
  46. 	return 0;
  47. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/738777
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号