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

数据结构（高阶）—— 红黑树

作者：Gausst松鼠会 | 2024-04-17 02:37:13

赞

踩

红黑树

目录

一、红黑树的概念

二、红黑树的性质

三、红黑树的结点定义

四、红黑树的插入

五、红黑树的验证

六、红黑树与AVL树的比较

一、红黑树的概念

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

二、红黑树的性质

红黑树有以下五点性质：

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

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

        1. 根据性质3和性质4，我们知道不能有连续的红节点，但是连续的黑节点是可以的，当某个路径中的节点全为黑时，就是该树的最短路径；

        2. 根据性质1和性质4，我们知道最长路径是由一个黑节点和一个红节点交替组成；

        3. 并且最后的叶子节点均是黑色结点（图上为标注）；

这样一来就能够保证最长路径中节点个数不会超过最短路径节点给树的两倍。

三、红黑树的结点定义

        对于红黑树的结点定义，我们依旧使用三叉链来实现，因为红黑树本质也是一种二叉搜索树，相比AVL树的节点定义，我们不再使用平衡因子来控制这里的平衡，而是通过控制颜色来控制平衡。

  1. //节点的颜色
  2. enum Colour
  3. {
  4. 	RED,
  5. 	BLACK
  6. };
  7.  
  8. //红黑树节点的定义
  9. template<class k,class v>
  10. struct RBTreeNode
  11. {
  12.     //三叉链
  13. 	RBTreeNode<k, v>* _left;   //节点的左孩子
  14. 	RBTreeNode<k, v>* _right;  //节点的右孩子
  15. 	RBTreeNode<k, v>* _parent; //节点的父亲
  16.  
  17. 	pair<k, v> _kv;//存储键值对
  18.  
  19. 	Colour _col;//利用枚举记录红黑结点
  20.  
  21.     //构造函数
  22. 	RBTreeNode(const pair<k, v>& kv)
  23. 		:_left(nullptr)
  24. 		, _right(nullptr)
  25. 		, _parent(nullptr)
  26. 		, _kv(kv)
  27. 		, _col(RED)
  28. 	{}
  29. };

        对于红黑树的插入来说，我们都是要通过构造红黑树节点来进行插入的，那么就有一个问题，究竟是构造红节点还是黑节点呢？

        对于左图的红黑树，插入的是黑色节点，破坏了性质4，就需要对红黑树进行调整，这里很显然插入一个黑色节点影响了所有路径；

        对于右图的红黑树，插入的是红色节点，破坏了性质3，但是性质4是具备的，这里显然只是局部发生的影响，并没有影响整棵红黑树；

        以上图为例，当插入的是红节点时，其父节点如果是黑色，那么将不需要调整红黑树；如果是红色节点也只是影响局部，简单调整；但是插入黑色节点就不一样了，无论你插在哪里，对整棵树的影响很大；此时两种节点的插入，所带来的性价比就很显然易见了；

        权衡利弊下：插入红节点最佳。所以我们在构造结点进行插入时，默认将结点的颜色设置为红色。

四、红黑树的插入

红黑树的插入分为以下两个步骤：

  1. 按照二叉搜索树的插入方法，找到并插入。
  2. 若插入节点的父节点是红色，则需要对红黑树进行调整。

        当插入节点的父节点为黑色时，我们是不需要对红黑树进行调整的，因为并没有破坏红黑树的5个性质；但是其父节点是红色时，就需要分为四种情况进行调整。

        首先规定如下：cur为当前（新增）节点、p为父节点、g为祖父节点、u为叔叔节点

cur —— current；p —— parent；g —— grandfather；u —— uncle

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

注意： 叔叔存在且为红时，cur结点是parent的左孩子还是右孩子，调整方法都是一样的。

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

说明：u的情况有两种

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

  • 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。

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

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

p、g变色–p变黑，g变红

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

1.p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；转换成了情况2，对g进行右单旋

2.p为g的右孩子，cur为p的左孩子，则针对p做右单旋转； 转换成了情况2，对g进行左单旋 

  1. bool Insert(const pair<k, v>& kv)
  2. {
  3. 	if (_root == nullptr)
  4. 	{
  5. 		_root = new Node(kv);
  6. 		_root->_col = BLACK;
  7. 		return true;
  8. 	}
  9.  
  10. 	Node* parent = nullptr;
  11. 	Node* cur = _root;
  12. 	while (cur)
  13. 	{
  14. 		if (cur->_kv.first < kv.first)
  15. 		{
  16. 			parent = cur;
  17. 			cur = cur->_right;
  18. 		}
  19. 		else if (cur->_kv.first > kv.first)
  20. 		{
  21. 			parent = cur;
  22. 			cur = cur->_left;
  23. 		}
  24. 		else
  25. 		{
  26. 			return false;
  27. 		}
  28. 	}
  29.  
  30. 	cur = new Node(kv);
  31. 	cur->_col = RED; // 新增节点
  32.  
  33. 	if (parent->_kv.first < kv.first)
  34. 	{
  35. 		parent->_right = cur;
  36. 		cur->_parent = parent;
  37. 	}
  38. 	else
  39. 	{
  40. 		parent->_left = cur;
  41. 		cur->_parent = parent;
  42. 	}
  43.  
  44. 	// 控制平衡
  45. 	while (parent && parent->_col == RED)
  46. 	{
  47. 		Node* grandfather = parent->_parent;
  48. 		if (parent == grandfather->_left) //parent是左孩子
  49. 		{
  50. 			Node* uncle = grandfather->_right;
  51. 			// 情况1、uncle存在且为红
  52. 			if (uncle && uncle->_col == RED)
  53. 			{
  54. 				// 变色+继续向上处理
  55. 				parent->_col = uncle->_col = BLACK;
  56. 				grandfather->_col = RED;
  57.  
  58. 				cur = grandfather;
  59. 				parent = cur->_parent;
  60. 			}
  61. 			else //情况2和3：uncle不存在 / 存在且为黑
  62. 			{
  63. 				if (cur == parent->_left)//如果新增结点在parent的左侧，即是情况2
  64. 				{
  65. 					// 单旋
  66. 					RotateR(grandfather);
  67. 					parent->_col = BLACK;
  68. 					grandfather->_col = RED;
  69. 				}
  70. 				else     //如果新增结点在parent的右侧，即是情况3
  71. 				{
  72. 					// 双旋
  73. 					RotateL(parent);
  74. 					RotateR(grandfather);
  75. 					cur->_col = BLACK;
  76. 					grandfather->_col = RED;
  77. 				}
  78. 				break;
  79. 			}
  80. 		}
  81. 		else // parent == grandfather->_right  //parent是右孩子
  82. 		{
  83. 			Node* uncle = grandfather->_left;
  84.             // 情况1、uncle存在且为红
  85. 			if (uncle && uncle->_col == RED)
  86. 			{
  87. 				// 变色+继续向上处理
  88. 				parent->_col = uncle->_col = BLACK;
  89. 				grandfather->_col = RED;
  90.  
  91. 				cur = grandfather;
  92. 				parent = cur->_parent;
  93. 			}
  94. 			else //情况2和3：uncle不存在 / 存在且为黑
  95. 			{
  96. 				if (cur == parent->_right)
  97. 				{
  98. 					RotateL(grandfather);
  99. 					parent->_col = BLACK;
  100. 					grandfather->_col = RED;
  101. 				}
  102. 				else
  103. 				{
  104. 					RotateR(parent);
  105. 					RotateL(grandfather);
  106. 					cur->_col = BLACK;
  107. 					grandfather->_col = RED;
  108. 				}
  109.  
  110. 				break;
  111. 			}
  112. 		}
  113. 	}
  114. 	_root->_col = BLACK;
  115. 	return true;
  116. }
  117.  
  118. //左单选
  119. void RotateL(Node* parent)
  120. {
  121. 	Node* subR = parent->_right;
  122. 	Node* subRL = subR->_left;
  123. 	parent->_right = subRL;
  124. 	if (subRL)
  125. 	{
  126. 		subRL->_parent = parent;
  127. 	}
  128. 	Node* parentParent = parent->_parent;
  129. 	subR->_left = parent;
  130. 	parent->_parent = subR;
  131.  
  132. 	if (parent == _root)//这里表明原来是根
  133. 	{
  134. 		_root = subR;
  135. 		subR->_parent = nullptr;
  136. 	}
  137. 	else
  138. 	{
  139. 		if (parentParent->_left == parent)
  140. 		{
  141. 			parentParent->_left = subR;
  142. 		}
  143. 		else
  144. 		{
  145. 			parentParent->_right = subR;
  146. 		}
  147. 		subR->_parent = parentParent;
  148. 	}
  149. }
  150.  
  151. //右单旋
  152. void RotateR(Node* parent)
  153. {
  154. 	Node* subL = parent->_left;
  155. 	Node* subLR = subL->_right;
  156. 	parent->_left = subLR;
  157.  
  158. 	if (subLR)
  159. 	{
  160. 		subLR->_parent = parent;
  161. 	}
  162. 	Node* parentParent = parent->_parent;
  163. 	subL->_right = parent;
  164. 	parent->_parent = subL;
  165. 	if (parent == _root)//这里表明原来是根
  166. 	{
  167. 		_root = subL;
  168. 		_root->_parent = nullptr;
  169. 	}
  170. 	else
  171. 	{
  172. 		if (parentParent->_left == parent)
  173. 		{
  174. 			parentParent->_left = subL;
  175. 		}
  176. 		else
  177. 		{
  178. 			parentParent->_right = subL;
  179. 		}
  180. 		subL->_parent = parentParent;
  181. 	}
  182. }

五、红黑树的验证

利用中序遍历先判断是否是二叉搜索树 

  1. void InOrder()
  2. {
  3. 	_InOrder(_root);
  4. }
  5.  
  6. void _InOrder(Node* root)
  7. {
  8. 	if (root == nullptr)
  9. 	{
  10. 		return;
  11. 	}
  12. 	_InOrder(root->_left);
  13. 	cout << root->_kv.first << ":" << root->_kv.second << endl;
  14. 	_InOrder(root->_right);
  15. }

        检测是否满足红黑树的性质：任意选取一条路径找出黑色结点的个数作为基准值，然后依次与其他路径比较，如果都相同则满足红黑树的性质；

  1. bool IsBalance()
  2. {
  3. 	if (_root && _root->_col == RED)
  4. 	{
  5. 		cout << "根结点不是黑色" << endl;//为了测试
  6. 		return false;
  7. 	}  
  8. 	//最左路径黑色结点数量做基准值
  9. 	int banchmark = 0;//保存最左侧路径中黑色结点的个数
  10. 	Node* left = _root;
  11. 	while (left) 
  12. 	{
  13. 		if (left->_col == BLACK)
  14. 			++banchmark;
  15. 		left = left->_left;
  16. 	}
  17.  
  18. 	int blackNum = 0;//递归遍历时记录黑色结点的个数
  19. 	return _IsBalance(_root, banchmark, blackNum);
  20. }
  21.  
  22. bool _IsBalance(Node* root, int banchmark, int blackNum)
  23. {
  24.     //走到null之后，判断banchmark和blackNum是否相等
  25. 	if (root == nullptr)
  26. 	{
  27. 		if (banchmark != blackNum)
  28. 		{
  29. 			cout << "存在路径黑色结点的数量不相等" << endl;//为了测试
  30. 			return false;
  31. 		}
  32. 		return true;
  33. 	}
  34. 	if (root->_col == RED && root->_parent->_col == RED)
  35. 	{
  36. 		cout<<"出现了连续的红色结点" << endl;//为了测试
  37. 		return false;
  38. 	}
  39. 	if (root->_col == BLACK)// 统计黑色节点的个数
  40. 	{
  41. 		++blackNum;
  42. 	}
  43. 	return _IsBalance(root->_left, banchmark, blackNum) 
  44. 		&& _IsBalance(root->_right, banchmark, blackNum);
  45. }

六、红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，

红黑树和AVL树控制二叉树平衡的方式不同：

  • AVL树是通过控制左右高度差不超过1来实现二叉树平衡的，实现的是二叉树的严格平衡。
  • 红黑树是通过控制结点的颜色，从而使得红黑树当中最长可能路径不超过最短可能路径的2倍，实现的是近似平衡。

        相对而言，红黑树降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

七、源代码

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. enum Colour
  5. {
  6. 	RED,
  7. 	BLACK
  8. };
  9.  
  10. template<class k,class v>
  11. struct RBTreeNode
  12. {
  13. 	RBTreeNode<k, v>* _left;
  14. 	RBTreeNode<k, v>* _right;
  15. 	RBTreeNode<k, v>* _parent;
  16. 	pair<k, v> _kv;
  17. 	Colour _col;
  18. 	RBTreeNode(const pair<k, v>& kv)
  19. 		:_left(nullptr)
  20. 		, _right(nullptr)
  21. 		, _parent(nullptr)
  22. 		, _kv(kv)
  23. 		, _col(RED)
  24. 	{}
  25. };
  26.  
  27. template<class k, class v>
  28. class RBTree
  29. {
  30. 	typedef RBTreeNode<k, v> Node;
  31. public:
  32. 	RBTree()
  33. 		:_root(nullptr)
  34. 	{}
  35. 	bool Insert(const pair<k, v>& kv)
  36. 	{
  37. 		if (_root == nullptr)
  38. 		{
  39. 			_root = new Node(kv);
  40. 			_root->_col = BLACK;
  41. 			return true;
  42. 		}
  43.  
  44. 		Node* parent = nullptr;
  45. 		Node* cur = _root;
  46. 		while (cur)
  47. 		{
  48. 			if (cur->_kv.first < kv.first)
  49. 			{
  50. 				parent = cur;
  51. 				cur = cur->_right;
  52. 			}
  53. 			else if (cur->_kv.first > kv.first)
  54. 			{
  55. 				parent = cur;
  56. 				cur = cur->_left;
  57. 			}
  58. 			else
  59. 			{
  60. 				return false;
  61. 			}
  62. 		}
  63.  
  64. 		cur = new Node(kv);
  65. 		cur->_col = RED; // 新增节点
  66. 		if (parent->_kv.first < kv.first)
  67. 		{
  68. 			parent->_right = cur;
  69. 			cur->_parent = parent;
  70. 		}
  71. 		else
  72. 		{
  73. 			parent->_left = cur;
  74. 			cur->_parent = parent;
  75. 		}
  76.  
  77. 		// 控制平衡
  78. 		while (parent && parent->_col == RED)
  79. 		{
  80. 			Node* grandfather = parent->_parent;
  81. 			if (parent == grandfather->_left)
  82. 			{
  83. 				Node* uncle = grandfather->_right;
  84. 				// 1、uncle存在且为红
  85. 				if (uncle && uncle->_col == RED)
  86. 				{
  87. 					// 变色+继续向上处理
  88. 					parent->_col = uncle->_col = BLACK;
  89. 					grandfather->_col = RED;
  90.  
  91. 					cur = grandfather;
  92. 					parent = cur->_parent;
  93. 				}
  94. 				else // 2 + 3、uncle不存在/ 存在且为黑
  95. 				{
  96. 					if (cur == parent->_left)
  97. 					{
  98. 						// 单旋
  99. 						RotateR(grandfather);
  100. 						parent->_col = BLACK;
  101. 						grandfather->_col = RED;
  102. 					}
  103. 					else
  104. 					{
  105. 						// 双旋
  106. 						RotateL(parent);
  107. 						RotateR(grandfather);
  108. 						cur->_col = BLACK;
  109. 						grandfather->_col = RED;
  110. 					}
  111. 					break;
  112. 				}
  113. 			}
  114. 			else // parent == grandfather->_right
  115. 			{
  116. 				Node* uncle = grandfather->_left;
  117. 				if (uncle && uncle->_col == RED)
  118. 				{
  119. 					// 变色+继续向上处理
  120. 					parent->_col = uncle->_col = BLACK;
  121. 					grandfather->_col = RED;
  122.  
  123. 					cur = grandfather;
  124. 					parent = cur->_parent;
  125. 				}
  126. 				else // 2 + 3、uncle不存在/ 存在且为黑
  127. 				{
  128. 					if (cur == parent->_right)
  129. 					{
  130. 						RotateL(grandfather);
  131. 						parent->_col = BLACK;
  132. 						grandfather->_col = RED;
  133. 					}
  134. 					else
  135. 					{
  136. 						RotateR(parent);
  137. 						RotateL(grandfather);
  138. 						cur->_col = BLACK;
  139. 						grandfather->_col = RED;
  140. 					}
  141.  
  142. 					break;
  143. 				}
  144. 			}
  145. 		}
  146. 		_root->_col = BLACK;
  147. 		return true;
  148. 	}
  149.  
  150. 	//左单选
  151. 	void RotateL(Node* parent)
  152. 	{
  153. 		Node* subR = parent->_right;
  154. 		Node* subRL = subR->_left;
  155. 		parent->_right = subRL;
  156. 		if (subRL)
  157. 		{
  158. 			subRL->_parent = parent;
  159. 		}
  160. 		Node* parentParent = parent->_parent;
  161. 		subR->_left = parent;
  162. 		parent->_parent = subR;
  163.  
  164. 		if (parent == _root)//这里表明原来是根
  165. 		{
  166. 			_root = subR;
  167. 			subR->_parent = nullptr;
  168. 		}
  169. 		else
  170. 		{
  171. 			if (parentParent->_left == parent)
  172. 			{
  173. 				parentParent->_left = subR;
  174. 			}
  175. 			else
  176. 			{
  177. 				parentParent->_right = subR;
  178. 			}
  179. 			subR->_parent = parentParent;
  180. 		}
  181. 	}
  182.  
  183. 	//由单旋
  184. 	void RotateR(Node* parent)
  185. 	{
  186. 		Node* subL = parent->_left;
  187. 		Node* subLR = subL->_right;
  188. 		parent->_left = subLR;
  189. 		if (subLR)
  190. 		{
  191. 			subLR->_parent = parent;
  192. 		}
  193. 		Node* parentParent = parent->_parent;
  194. 		subL->_right = parent;
  195. 		parent->_parent = subL;
  196. 		if (parent == _root)//这里表明原来是根
  197. 		{
  198. 			_root = subL;
  199. 			_root->_parent = nullptr;
  200. 		}
  201. 		else
  202. 		{
  203. 			if (parentParent->_left == parent)
  204. 			{
  205. 				parentParent->_left = subL;
  206. 			}
  207. 			else
  208. 			{
  209. 				parentParent->_right = subL;
  210. 			}
  211. 			subL->_parent = parentParent;
  212. 		}
  213. 	}
  214.  
  215. void InOrder()
  216. {
  217. 	_InOrder(_root);
  218. }
  219.  
  220. void _InOrder(Node* root)
  221. {
  222. 	if (root == nullptr)
  223. 	{
  224. 		return;
  225. 	}
  226. 	_InOrder(root->_left);
  227. 	cout << root->_kv.first << ":" << root->_kv.second << endl;
  228. 	_InOrder(root->_right);
  229. }
  230.  
  231. 	bool IsBalance()
  232. 	{
  233. 		if (_root && _root->_col == RED)
  234. 		{
  235. 			cout << "根结点不是黑色" << endl;
  236. 			return false;
  237. 		}  
  238. 		//最左路径黑色结点数量做基准值
  239. 		int banchmark = 0;
  240. 		Node* left = _root;
  241. 		while (left) 
  242. 		{
  243. 			if (left->_col == BLACK)
  244. 				++banchmark;
  245. 			left = left->_left;
  246. 		}
  247. 		int blackNum = 0;
  248. 		return _IsBalance(_root, banchmark, blackNum);
  249. 	}
  250.  
  251. 	bool _IsBalance(Node* root, int banchmark, int blackNum)
  252. 	{
  253. 		if (root == nullptr)
  254. 		{
  255. 			if (banchmark != blackNum)
  256. 			{
  257. 				cout << "存在路径黑色结点的数量不相等" << endl;
  258. 				return false;
  259. 			}
  260. 			return true;
  261. 		}
  262. 		if (root->_col == RED && root->_parent->_col == RED)
  263. 		{
  264. 			cout<<"出现了连续的红色结点" << endl;
  265. 			return false;
  266. 		}
  267. 		if (root->_col == BLACK)
  268. 		{
  269. 			++blackNum;
  270. 		}
  271. 		return _IsBalance(root->_left, banchmark, blackNum) 
  272. 			&& _IsBalance(root->_right, banchmark, blackNum);
  273. 	}
  274.  
  275. 	int Height()
  276. 	{
  277. 		return _Height(_root);
  278. 	}
  279. 	int _Height(Node* root)
  280. 	{
  281. 		if (root == nullptr)
  282. 		{
  283. 			return 0;
  284. 		}
  285. 		int leftHeight = _Height(root->_left);
  286. 		int rightHeight = _Height(root->_right);
  287. 		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
  288. 	}
  289.  
  290. private:
  291. 	Node* _root;
  292. };
  293.  
  294. void TestRBTree()
  295. {
  296. 	RBTree<int, int> t;
  297. 	//int a[] = { 5,4,3,2,1,0 };
  298. 	int a[] = { 16,3,7,11,9,26,18,14,15 };
  299. 	//int a[] = { 4,2,6,1,3,5,15,7,16,14 };
  300. 	for (auto e : a)
  301. 	{
  302. 		t.Insert(make_pair(e, e));
  303. 		//cout << "Insert" << e << ":" << t.IsBalance() << endl;
  304. 	}
  305. 	t.InOrder();
  306. 	cout << t.IsBalance() << endl;
  307. 	cout << t.Height() << endl;
  308.  
  309. }

 

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

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

  

闽ICP备14008679号