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

【数据结构】二叉树---红黑树的实现

作者：花生_TL007 | 2024-04-02 20:06:42

赞

踩

【数据结构】二叉树---红黑树的实现

目录

一.  红黑树的概念及性质

二.  红黑树结点结构的定义

三.  红黑树的插入操作

     1. 情况一

     2. 情况二

       3. 情况三

四.  红黑树的验证

五.  红黑树与AVL树的比较

一.  红黑树的概念及性质

红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，
可以是红色或黑色。

红黑树具有以下性质：

   1. 每个结点要么是红色，要么是黑色。
   2. 根结点是黑色。
   3. 每个叶结点（NIL结点，空结点）是黑色。
   4. 如果一个结点是红色，则它的子结点必须是黑色(所有路径上不能有两个连续的红色节点)
   5. 从任一结点到其每个叶子的所有路径都包含相同数目的黑色结点。


        这些性质保证了红黑树的关键性质，从根到叶子的最长路径不会超过最短路径的两倍，从而保证了红黑树的平衡性。红黑树常被用于实现集合和映射等数据结构，因为其在插入、删除等操作上具有较好的性能表现

二.  红黑树结点结构的定义

红黑树节点结构通常包含以下几个字段：

       键值（key）：用于比较和排序节点的值。
       指向父节点的指针（parent）：指向当前节点的父节点。
       指向左节点的指针（left）：指向当前节点的左节点。
       指向右节点的指针（right）：指向当前节点的右节点。
       颜色（color）：表示节点的颜色，通常用一个位来表示，比如红色和黑色。

红黑树节点结构的定义表示如下：

在这里通过定义枚举结构来表示红、黑两种颜色

  1. //定义结点的颜色
  2. enum Color
  3. {
  4. 	RED,    //表示红色
  5. 	BLACK   //表示黑色
  6. };
  7.  
  8. //红黑树的结点定义类模板
  9. template<class T>
  10. struct RBTreeNode
  11. {
  12. 	RBTreeNode<T>* _left;    //指向左结点
  13. 	RBTreeNode<T>* _right;   //指向右节点
  14. 	RBTreeNode<T>* _parent;  //指向父节点(红黑树需要旋转，为了实现简单给出该字段)          
  15. 	T _data;        //结点值
  16. 	Color _col;     //结点的颜色
  17.  
  18.     //结点的构造函数
  19. 	RBTreeNode(const T& data)
  20. 		:_left(nullptr)
  21. 		, _right(nullptr)
  22. 		, _parent(nullptr)
  23. 		, _data(data)
  24. 		, _col(RED)      //默认初始化红色
  25. 	{}
  26.  
  27. };

注意：这里将插入结点的默认颜色给成红色

  

       当插入一个新节点时，如果将该节点默认设置为黑色，可能会破坏红黑树的性质，需要进行额外的操作来恢复平衡。而将新插入的节点默认设置为红色，是为了满足红黑树的性质，特别是在插入节点时能够更容易地维持这些性质。红黑树的性质要求如果一个节点是红色，则其子节点必须是黑色，这是为了确保从根节点到叶子节点的每条路径上黑色节点的数量相等，从而保持树的平衡性。

       因此，将节点的默认颜色设置为红色是为了简化插入操作，并确保在插入新节点后能够更轻松地维护红黑树的平衡性。

三.  红黑树的插入操作

       因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质4，不能有连续的红色节点，此时需要对红黑树分情况来讨论：

说明：这里所用到的字段
                C 表示当前新插入节点，

                P 表示父节点(当前节点的父节点)，
                G 表示祖父节点(父节点的父节点)，

                U 表示叔叔节点(父节点的兄弟节点)

     1. 情况一

新插入节点(C)的父节点(P)是红色，且新插入节点的叔叔节点(U)(父节点的兄弟节点) 存在且是红色。
这时需要进行颜色调整和递归调整。     

颜色调整：将 P 和 U 改为 黑，G 改为 红

注意：G若为根结点，则改为黑色

           G若为子树，则继续递归向上调整

     2. 情况二

新插入节点(C)的父节点(P)是红色，但新插入结点的叔叔节点(U)是黑色或空节点：

 叔叔结点（U）不为空：

    1. 父节点(P)是其祖父节点(G)的左节点，新插入节点(C)是其父节点(P)的右节点，左单旋转

    2. 父节点(P)是其祖父节点(G)的右节点，新插入节点(C)是其父节点(P)的左节点，右单旋转


 颜色调整 ：G 改为 红，C 改为 黑            

       3. 情况三

新节点(C)的父节点(P)是红色，但新节点的叔叔节点(U)是黑色或空节点：

 叔叔结点（U）为空：

    1. 父节点(P)是其祖父节点(G)的左节点，新插入节点(C)是其父节点(P)的左节点，右单旋转

    2. 父节点(P)是其祖父节点(G)的右节点，新插入节点(C)是其父节点(P)的右节点，左单旋转

颜色调整 ：P 改为 黑，G 改为 红

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

四.  红黑树的验证

红黑树的验证分为两步：

     1. 验证其是否满足二叉搜索树

                中序遍历是否为有序序列

     2. 验证其是否满足红黑树的性质

              1. 根是黑色的
              2. 没有连续的红色节点
              3. 每条路径的黑色节点的数量相等

  1. 	//中序遍历 验证是否有序
  2.     void InOrder(Node* root)
  3. 	{
  4. 		if (root == nullptr)
  5. 			return;
  6. 		InOrder(root->_left);
  7. 		cout << root->_data << " ";
  8. 		InOrder(root->_right);
  9.  
  10. 	}
  11.  
  12.     //验证是否满足红黑树的性质
  13.     bool IsValidRBTRee()
  14. 	{
  15. 		if (_root && _root->_col == RED)
  16. 			return false;
  17.  
  18. 		int refBlackNum = 0;  //作为路径上黑色节点的参考值
  19. 		Node* cur = _root;
  20. 		while (cur)
  21. 		{
  22. 			if (cur->_col == BLACK)
  23. 				refBlackNum++;
  24. 			cur = cur->_left;
  25. 		}
  26. 		return _IsValidRBTRee(_root, 0, refBlackNum);
  27. 	}
  28.  
  29.     // 检测红黑树是否为有效的红黑树
  30. 	bool _IsValidRBTRee(Node* root, int blackNum, int refBlackNum)
  31. 	{
  32. 		if (root == nullptr)  //每条路径的黑色节点的数量是否相等
  33. 		{
  34. 			if (blackNum != refBlackNum)
  35. 			{
  36. 				cout << "黑色节点的数量不相等" << endl;
  37. 				return false;
  38. 			}
  39. 			cout << blackNum << endl;   
  40. 			return true;
  41. 		}
  42.  
  43.         //是否存在连续的红节点
  44. 		if (root->_col == RED && root->_parent->_col == RED)
  45. 		{
  46. 			cout << root->_kv.first << "存在连续的红色节点" << endl;
  47. 			return false;
  48. 		}
  49.         
  50.         // 统计黑色节点的个数
  51. 		if (root->_col == BLACK)
  52. 		{
  53. 			blackNum++;
  54. 		}
  55.  
  56. 		return _IsValidRBTRee(root->_left, blackNum, refBlackNum)
  57. 			&& _IsValidRBTRee(root->_right, blackNum, refBlackNum);
  58. 	}

五.  红黑树与AVL树的比较

红黑树和AVL树是两种常见的自平衡二叉搜索树结构。它们都可以保持树的平衡，以确保在插入和删除操作后，树的高度始终保持在较小的范围内，从而保证了检索、插入和删除操作的时间复杂度为O(logn)。

 一，对平衡性要求：  

        1. AVL树要求严格的平衡性，即任意节点的左右子树的高度差的绝对值不超过1。

        2. 红黑树放宽了对平衡性的要求，它通过引入红黑节点的颜色来保持大致平衡，即任意节点的黑结点高度相等

二，插入和删除操作的性能：

        1. AVL树对插入和删除操作的平均性能略低于红黑树，因为AVL树需要更频繁地进行旋转操作来保持严格的平衡。

        2. 红黑树在插入和删除操作时的性能相对较好，因为它对平衡性的要求较松，旋转的次数相对较少

三，查询性能：

        由于两种树结构的高度始终保持在较小范围内，它们的查询性能相似，都为O(logn)

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

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

  

闽ICP备14008679号