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

[ 数据结构 - C++]红黑树RBTree_c++ rb-tree

作者：小蓝xlanll | 2024-03-16 01:31:07

赞

踩

c++ rb-tree

在上篇文章我们了解了第一种平衡二叉搜索树AVL树，我们知道AVL树是通过平衡因子来控制左右子树高度差，从而将二叉树变成一颗平衡二叉搜索树。本篇文章我们将要了解另外一种平衡规则控制的二叉搜索树--红黑树（RBTree）

目录

1.红黑树的概念

2.红黑树的性质

3.红黑树节点的定义

4.红黑树的插入Insert

代码实现：

5.红黑树的验证

6.红黑树与AVL树的比较

7.红黑树测试

附录：

1.红黑树的概念

红黑树是一种二叉搜索树，在二叉树的每个节点上增加一个存储为表示该节点的颜色。颜色可以红色（RED）或黑色（BLACK）。通过对任意一条从根到叶子的路径上各个节点着色方式的限制，红黑树确保没有一条路径会比其他路径长2倍，因而是接近平衡的。(例如：下图正是一颗红黑树)

2.红黑树的性质

根据上图示例，我们能够发现一颗红黑树具有如下几条性质：

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

满足以上红黑树的性质，就能保证该棵树是一颗平衡树吗？为什么？

我们在概念中提到，红黑树确保没有一条路径会比其他路径长2倍，因而是接近平衡的。因此问题就转变为为什么如果这颗树是一颗红黑树，就能保证其最长路径中节点个数不会超过最短路径节点个数的两倍？

  • 根据第三点，红色节点的孩子是黑色的，这点能保证没有连续的两个红色节点。
  • 根据第四点，从该节点到后代的叶子路径上，包含数量相同的黑色节点，此处假如是从根节点计算，最坏情况下根节点左孩子为空，此时说明了从根节点开始一条路径上只有2个黑色节点(不包含NULL节点)，这也要求了根节点的右孩子必须且有2个黑色节点，此时根节点的右孩子可以存在一个红色节点，但是配合第三点，如果存在红色节点且红色节点的孩子一定是黑色的，此时右子树中任意一条路径的黑色节点已经达到两个，说明不能再存在黑色节点了，因此在黑色几点下最后链接一个红色节点右子树就需要停止。（如下图所示为例）

此时我们发现最短的路径长度为2（15->9）,最长的路径长度为4（15->19->17->16）【其一】，这也就验证了一颗红黑树中，其最长路径中的节点个数不会超过最短路径中的节点个数的两倍！

3.红黑树节点的定义

我们依然才从KV模型来建立节点。较AVL树而言，红黑树多了一个Colour而少了一个_bf，但是结构大体相同。

  1. enum Colour
  2. {
  3. 	RED,
  4. 	BLACK,
  5. };
  6.  
  7. template<class K,class V>
  8. struct RBTreeNode
  9. {
  10. 	pair<K, V> _kv;
  11. 	RBTreeNode* _left;
  12. 	RBTreeNode* _right;
  13. 	RBTreeNode* _parent;
  14.  
  15. 	Colour _col;//节点的颜色
  16.  
  17. 	RBTreeNode(const pair<K, V>& kv)
  18. 		:_kv(kv)
  19. 		,_left(nullptr)
  20. 		,_right(nullptr)
  21. 		,_parent(nullptr)
  22. 		,_col(RED)
  23. 	{}
  24.  
  25. };

在上述红黑树节点的定义中，新节点的_col默认给成红色是有意为之还是红黑色都可以呢？

当我们插入一个节点之后，可能会破坏红黑树的规则，因此我们插入一个节点要尽可能的少破坏红黑树的规则。而插入红色节点是，可能会破坏性质3，因为可能会导致连续的红色节点；而插入黑色节点是，会一定破坏性质4，因为插入一个黑色节点必然会使插入节点的这一条路径黑色几点个数增加1，从而导致性质4被破坏，因此从破坏力度来说选择红色节点，插入红色节点可能破坏性质3，插入黑色节点一定破坏性质4。

从维护红黑树的角度来说，也是破坏4更难维护，因为它牵扯到每一条路径，可能会让红黑树产生翻天覆地的变化(具体详情往下看Insert)。

4.红黑树的插入Insert

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

1.按照儿茶搜索树的规则插入新节点

2.检测新节点插入后，红黑树的性质是否被破坏。

  1. bool Insert(const pair<K, V>& kv)
  2. {
  3. 	//1.搜索树的规则插入
  4. 	//2.看是否违反平衡规则，如果违反就需要处理：旋转
  5. 	if (_root == nullptr)
  6. 	{
  7. 		_root = new Node(kv);
  8. 		_root->_col = BLACK;//性质2：根节点为黑色
  9. 		return true;
  10. 	}
  11. 	Node* parent = nullptr;
  12. 	Node* cur = _root;
  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;
  28. 			}
  29. 		}
  30. 	//找到正确位置了
  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. 	//......
  44. }

当走完上述代码后，我们知道此时新节点已经插入到正确的位置了，现在要做的是检查和维护这颗红黑树。

  1. 如果双亲节点的颜色是黑色，那说明没有违反红黑树的任何性质，则不需要调整。
  2. 当新插入节点的双亲节点颜色红色时，此时违反性质三（不能有连续的红色节点），此时需要对红黑树进行调整。调整需分情况来讨论：（约定cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点）
    1. 情况一：cur为红，p为红，g为黑，u存在且为红

注意：此处看到的树，可能是一颗完整的树，也可能是一颗子树。

如果g是根节点，调整完成后，需要将g改为黑色

如果g是子树，g一定有双亲，且g的双亲如果是红色，需要继续向上调整

cur和p均为红，违反了性质3。解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

    1. 情况二：cur为红，p为红，g为黑，u不存在/u存在且为黑

说明：u的情况有两种：

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

p为g的左孩子，cur为p的左孩子则进行右单旋；

p为g的右孩子，cur为p的右孩子，则进行左单旋；

p，g变色--p变成黑，g变成红。（旋转规则在AVL树中有详细讲解，大家可参考上篇博文）

    1. 情况三：cur为红，p为红，g为黑，u不存在/u存在且为黑

p为g的左孩子，cur为p的右孩子，则针对p做左单旋；

p为g的右孩子，cur为p的左孩子，则针对p做右单旋；

则转换为了情况二。

代码实现：

  1. bool Insert(const pair<K, V>& kv)
  2. 	{
  3. 		//1.搜索树的规则插入
  4. 		//2.看是否违反平衡规则，如果违反就需要处理：旋转
  5. 		if (_root == nullptr)
  6. 		{
  7. 			_root = new Node(kv);
  8. 			_root->_col = BLACK;
  9. 			return true;
  10. 		}
  11. 		Node* parent = nullptr;
  12. 		Node* cur = _root;
  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;
  28. 			}
  29. 		}
  30. 		//找到正确位置了
  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. 		//存在连续的红色节点
  44. 		while (parent && parent->_col == RED)
  45. 		{
  46. 			Node* grandfather = parent->_parent;
  47. 			assert(grandfather);
  48. 			if (grandfather->_left == parent)
  49. 			{
  50. 				Node* uncle = grandfather->_right;
  51. 				//情况1：
  52. 				if (uncle && uncle->_col == RED)//叔叔存在且为红
  53. 				{
  54. 					//变色
  55. 					parent->_col = uncle->_col = BLACK;
  56. 					grandfather->_col = RED;
  57.  
  58. 					//继续往上调整
  59. 					cur = grandfather;
  60. 					parent = cur->_parent;
  61. 				}
  62. 				else//叔叔不存在 或者 叔叔存在且为黑
  63. 				{
  64. 					if (cur == parent->_left)
  65. 					{
  66. 						//     g
  67. 						//   p
  68. 						// c
  69. 						RotateR(grandfather);
  70. 						parent->_col = BLACK;
  71. 						grandfather->_col = RED;
  72. 					}
  73. 					else//双旋
  74. 					{
  75. 						//    g
  76. 						//  p
  77. 						//    c
  78. 						RotateL(parent);
  79. 						RotateR(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. 				//情况一：
  90. 				if (uncle && uncle->_col == RED)
  91. 				{
  92. 					//变色
  93. 					parent->_col = uncle->_col = BLACK;
  94. 					grandfather->_col = RED;
  95.  
  96. 					//继续往上处理
  97. 					cur = grandfather;
  98. 					parent = cur->_parent;
  99. 				}
  100. 				else
  101. 				{
  102. 					if (cur == parent->_right)
  103. 					{
  104. 						// g
  105. 						//   p
  106. 						//     c
  107. 						RotateL(grandfather);
  108. 						parent->_col = BLACK;
  109. 						grandfather->_col = RED;
  110. 					}
  111. 					else //双旋
  112. 					{
  113. 						// g
  114. 						//   p
  115. 						// c
  116. 						RotateR(parent);
  117. 						RotateL(grandfather);
  118. 						cur->_col = BLACK;
  119. 						grandfather->_col = RED;
  120. 					}
  121.  
  122. 					break;
  123. 				}
  124.  
  125. 			}
  126. 		}
  127.  
  128. 		//处理根 一定是黑色
  129. 		_root->_col = BLACK;
  130. 		return true;
  131. 	}
  132. 	//左旋
  133. 	void RotateL(Node* parent)
  134. 	{
  135. 		Node* subR = parent->_right;
  136. 		Node* subRL = subR->_left;
  137.  
  138. 		parent->_right = subRL;
  139. 		if (subRL)
  140. 			subRL->_parent = parent;
  141.  
  142. 		Node* ppNode = parent->_parent;
  143.  
  144. 		subR->_left = parent;
  145. 		parent->_parent = subR;
  146.  
  147. 		if (parent == _root)
  148. 		{
  149. 			_root = subR;
  150. 			_root->_parent = nullptr;
  151. 		}
  152. 		else
  153. 		{
  154. 			if (parent == ppNode->_left)
  155. 			{
  156. 				ppNode->_left = subR;
  157. 			}
  158. 			else
  159. 			{
  160. 				ppNode->_right = subR;
  161. 			}
  162. 			subR->_parent = ppNode;
  163. 		}
  164. 	}
  165. 	//右旋
  166. 	void RotateR(Node* parent)
  167. 	{
  168. 		Node* subL = parent->_left;
  169. 		Node* subLR = subL->_right;
  170.  
  171. 		parent->_left = subLR;
  172. 		if (subLR)
  173. 			subLR->_parent = parent;
  174. 		
  175. 		Node* ppNode = parent->_parent;
  176.  
  177. 		subL->_right = parent;
  178. 		parent->_parent = subL;
  179. 		if (parent == _root)
  180. 		{
  181. 			_root = subL;
  182. 			_root->_parent = nullptr;
  183. 		}
  184. 		else
  185. 		{
  186. 			if (ppNode->_left == parent)
  187. 			{
  188. 				ppNode->_left = subL;
  189. 			}
  190. 			else
  191. 			{
  192. 				ppNode->_right = subL;
  193. 			}
  194. 			subL->_parent = ppNode;
  195. 		}
  196. 	}

5.红黑树的验证

红黑树的验证检测分为两步：

1.检测其是否满足二叉搜索树（中序遍历是否有序）

2.检测其是否满足红黑树的性质

  1.     //检测第一步：是否为二叉搜索树
  2. 	void _InOrder(Node* root)
  3. 	{
  4. 		if (root == nullptr)
  5. 			return;
  6. 		_InOrder(root->_left);
  7. 		cout << root->_kv.first << " ";
  8. 		_InOrder(root->_right);
  9. 	}
  10. 	//检测第二步：是否满足性质
  11. 	bool _IsValidRBTree(Node* pRoot, size_t k, const size_t blackCount)
  12. 	{
  13. 		//走到null之后,判断k和black是否相等
  14. 		if (nullptr == pRoot)
  15. 		{
  16. 			if (k != blackCount)
  17. 			{
  18. 				cout << "违反性质四，每条路径中黑色节点的个数必须相同" << endl;
  19. 				return false;
  20. 			}
  21. 			return true;
  22. 		}
  23.  
  24. 		//统计黑色节点的个数
  25. 		if (BLACK == pRoot->_col)
  26. 			k++;
  27.  
  28. 		//监测当前节点与其双亲是否都为红色
  29. 		if (RED == pRoot->_col && pRoot->_parent && pRoot->_parent->_col == RED)
  30. 		{
  31. 			cout << "违反性质三:存在连在一起的红色节点" << endl;
  32. 			return false;
  33. 		}
  34.  
  35. 		return _IsValidRBTree(pRoot->_left, k, blackCount) &&
  36. 			_IsValidRBTree(pRoot->_right, k, blackCount);
  37. 	}

6.红黑树与AVL树的比较

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

7.红黑树测试

红黑树测试时，我们需要知道其最长路径和其最短路径。

  1.     int _maxHeight(Node* root)
  2. 	{
  3. 		if (root == nullptr)
  4. 			return 0;
  5. 		int lh = _maxHeight(root->_left);
  6. 		int rh = _maxHeight(root->_right);
  7.  
  8. 		return lh > rh ? lh + 1 : rh + 1;
  9. 	}
  10.  
  11. 	int _minHeight(Node* root)
  12. 	{
  13. 		if (root == nullptr)
  14. 			return 0;
  15. 		int lh = _minHeight(root->_left);
  16. 		int rh = _minHeight(root->_right);
  17.  
  18. 		return lh < rh ? lh + 1 : rh + 1;
  19. 	}

我们可以生成随机数和生成有序数来加以验证

  1. void TestRBTree2()
  2. {
  3. 	const size_t N = 1024*1024;
  4. 	vector<int> v;
  5. 	v.reserve(N);
  6. 	srand(time(0));
  7. 	for (size_t i = 0; i < N; ++i)
  8. 	{
  9. 		//v.push_back(rand());
  10. 		v.push_back(i);
  11. 	}
  12.  
  13. 	RBTree<int, int> t;
  14. 	for (auto e : v)
  15. 	{
  16. 		t.Insert(make_pair(e, e));
  17. 	}
  18.  
  19. 	//t.levelOrder();
  20. 	cout << endl;
  21. 	cout << endl;
  22. 	cout << "是否平衡?" << t.IsBalanceTree() << endl;
  23. 	t.Height();
  24.  
  25. 	//t.InOrder();
  26. }

首先我们使用有序数来验证，我们将使用N=1024*1024个数据进行测试

接下来我们使用随机数来验证，仍然使用N=1024*1024个数据进行测试

我们发现，我们自构的红黑树均完成了以上测试。

附录：

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

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

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