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

【C++】-- 红黑树详解_c++ 红黑树

作者：IT小白 | 2024-03-10 20:15:44

赞

踩

c++ 红黑树

目录

一、红黑树概念

 1.概念 

 2.性质

二、红黑树定义

 1.红黑树节点定义

（1）将新插入节点置为红色

（2）将新插入节点置为黑色

2.红黑树定义

 三、红黑树插入

1.插入节点

2.控制颜色 

（1）父亲为黑色

（2）父亲是红色

四、红黑树颜色处理

1.cur红，p红，g黑，u存在且为红

（1）抽象图

（2）具象图

2. cur为红，p为红，g为黑，u为黑或u不存在（单旋）

（1）抽象图 

（2）具象图 

3.cur为红，p为红，g为黑，u不存在或u为黑（双旋）

（1）抽象图

（2）具象图

4.红黑树节点插入代码

五、红黑树查找

六、红黑树检查是否平衡

七、红黑树遍历

八、红黑树验证 

一、红黑树概念

 1.概念 

红黑树也是一种二叉搜索树，在每个结点上增加一个存储位，来表示该节点的颜色，节点要么是红色要么是黑色。

 2.性质

红黑树具有以下性质：

（1）每个结点不是红色就是黑色

（2）根节点是黑色的

（3）没有连续的红色节点

（4）每条路径上都包含相同数目的黑色节点

由于（3）和（4）互相控制，因此满足以上性质就能保证：最长路径中节点个数不会超过最短路径节点个数的2倍。

最短路径：全部由黑色节点构成

最长路径：由一黑一红构成，且红色节点数量等于黑色节点数量。

假设黑色节点有N个，最短路径长度为最长路径长度为2*。但是在红黑树中，不一定有最短路径和最长路径。

二、红黑树定义

 1.红黑树节点定义

红黑树节点相比于AVL树，多了一个颜色，因此需要一个成员变量来存储节点颜色。AVL树用高度严格控制平衡。红黑树近似平衡，所以不需要平衡因子。

但是红黑树节点的构造函数在初始化节点时，肯定要初始化节点颜色的，那么颜色需要一开始初始化成红色，因为初始化成红色，可能破坏规则（3），影响不大。但是假如将节点初始化成黑色，一定会破坏规则（4）。

（1）将新插入节点置为红色

假如将新插入节点置为红色，会有以下两种情况： 

①当父亲是黑色时，没有破坏规则（3），也没有破坏规则（4）

②当父亲是红色时，破坏了规则（3），但是只需要改变一下颜色即可

（2）将新插入节点置为黑色

但是假如将新节点初始化成黑色，不管父亲是黑色还是红色，一定会破坏规则（4），并且影响其他路径，影响范围广。

 ①当父亲是黑色时，破坏了规则（4）

 ②当父亲是红色时，也破坏了规则（4）

 ​​

 

因此节点要初始化成红色。

  1. //红黑树节点颜色
  2. enum Colour
  3. {
  4. 	RED,
  5. 	BLACK,
  6. };
  7.  
  8. //红黑树节点定义
  9. template<class K,class V>
  10. struct RBTreeNode
  11. {
  12. 	RBTreeNode<K, V>* _left;//节点的左孩子
  13. 	RBTreeNode<K, V>* _right;//节点的右孩子
  14. 	RBTreeNode<K, V>* _parent;//节点的父亲
  15.  
  16. 	pair<K,V> _kv;//节点的值
  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. };

2.红黑树定义

  1. template<class K,class V>
  2. class RBTree
  3. {
  4. 	typedef RBTreeNode<K, V> Node;
  5.  
  6.     //构造函数
  7.     RBTree()
  8. 		:_root(nullptr)
  9. 	{}
  10.  
  11. private:
  12. 	Node* _root;
  13. };

 三、红黑树插入

1.插入节点

插入节点分为2步： 

（1） 先查找，如果树中已存在该节点，则插入失败

（2）树中不存在该节点，插入

  1.     //插入
  2. 	pair<Node*, bool> Insert(const pair<K, V>& kv)
  3. 	{
  4. 		if (_root == nullptr)
  5. 		{
  6. 			_root = new Node(kv);
  7. 			_root->_col = BLACK;
  8. 			return make_pair(_root, true);
  9. 		}
  10.  
  11. 		//1.先看树中，kv是否存在
  12. 		Node* parent = nullptr;
  13. 		Node* cur = _root;
  14. 		while (cur)
  15. 		{
  16. 			if (cur->_kv.first < kv.first)
  17. 			{
  18. 				//kv比当前节点值大，向右走
  19. 				parent = cur;
  20. 				cur = cur->_right;
  21. 			}
  22. 			else if (cur->_kv.first > kv.first)
  23. 			{
  24. 				//kv比当前节点值小，向左走
  25. 				parent = cur;
  26. 				cur = cur->_left;
  27. 			}
  28. 			else
  29. 			{
  30. 				//kv和当前节点值相等，已存在，插入失败
  31. 				return make_pair(cur, false);
  32. 			}
  33. 		}
  34.  
  35. 		//2.走到这里，说明kv在树中不存在，需要插入kv，并且cur已经为空，parent已经是叶子节点了
  36. 		Node* newNode = new Node(kv);
  37. 		newNode->_col = RED;
  38. 		if (parent->_kv.first < kv.first)
  39. 		{
  40. 			//kv比parent值大，插入到parent的右边
  41. 			parent->_right = newNode;
  42. 			cur->_parent = parent;
  43. 		}
  44. 		else
  45. 		{
  46. 			//kv比parent值小，插入到parent的左边
  47. 			parent->_left = newNode;
  48. 			cur->_parent = parent;
  49. 		}
  50. 		cur = newNode;
  51.  
  52. 		return make_pair(cur, true);
  53. 	}

2.控制颜色 

所以在插入节点之后，为了满足红黑树的性质，还需要调整节点颜色：

（1）父亲为黑色

如果父亲是黑色，那么不需要调整，4个规则都满足，插入已完成

（2）父亲是红色

如果父亲是红色，违反了规则（3），需要调整颜色

 这时就需要对树中的节点进行颜色处理了。

四、红黑树颜色处理

 所有插入的新节点颜色都是红色，当父亲是红色时，需要进行颜色处理，分3种情况进行处理。在这3种情况中，cur为新插入节点，p为父亲节点，u为叔叔节点，g为祖父节点。下面的树都可能是一棵完整的树，也有可能是一棵子树。

1.cur红，p红，g黑，u存在且为红

当cur为红，p为红，g为黑，u存在且为红时，为了满足红黑树的性质，处理方法：将p和u变黑，g变红

（1）抽象图

如下a、b、c、d、e都是子树：

（1）假如g是根节点，根据红黑树性质，根节点必须是黑色，那就把g再变黑就好了

（2）假如g不是根节点，g是子树，那么g还有parent节点。

①如果g的parent是黑色，满足红黑树性质，那么停止调整。

②如果g的parent是红色，就破坏了规则（3），那么还需要继续向上调整。

 调整方法为：把g当作cur，继续向上调整，直到p不存在，或p存在且为黑停止。

（2）具象图

①g是根节点，直接把p和u变黑，g变红

②g不是根节点，g是子树，把p和u变黑，g变红之后，还要继续向上调整，直到p不存在，或p存在且为黑停止

2. cur为红，p为红，g为黑，u为黑或u不存在（单旋）

这种情况下，g、p、cur形成直线，先看cur为红，p为红，g为黑，u为黑的情况

这是由情况一cur红，p红，g黑，u存在且为红处理以后变换而来，比如以下情况：

 在这种情况下，cur原来的颜色一定是黑色，只不过在处理的过程当中，将cur的颜色变成了红色，所以cur不是新增节点，而是新增节点的祖先节点。

（1）抽象图 

 如下a、b、c、d、e都是子树，由于要旋转，所以要分为两种情况：当p是g的左子树，cur是p的左子树时，g右单旋，p变黑，g变红：

当p是g的右子树，cur是p的右子树时，g左单旋，p变黑，g变红： 

（2）具象图 

cur是新增节点的祖先节点，那么a、b一定不为空，由于从g到u的路径上有2个黑色节点，那么a和b都存在一个黑色节点，因此，c中也有一个黑色节点，才能满足每条路径上有相同数目的黑色节点。因此d、e要么同时不存在，要么同时为空。

当p是g的左子树，cur是p的左子树时，将节点g右单旋，p变黑，g变红：

 

当p是g的右子树，cur是p的右子树时，将节点g左单旋，p变黑，g变红：

再看cur为红，p为红，g为黑，u不存在的情况：

u不存在的情况更为简单，假如p是g的左子树，cur是p的左子树，将节点g右单旋，p变黑，g变红即可 

​​​​​​​​​​​​​​

 假如p是g的右子树，cur是p的右子树，将节点g左单旋，p变黑，g变红即可 

3.cur为红，p为红，g为黑，u不存在或u为黑（双旋）

这种情况下g、p、cur形成折线，先看cur为红，p为红，g为黑，u为黑的情况：

（1）抽象图

当p是g的左子树，cur是p的右子树时，处理方法：p左单旋，g右单旋，cur变黑，g变红：

 当p是g的右子树，cur是p的左子树时，处理方法：p右单旋，就变成了情况二

（2）具象图

 当p是g的左子树，cur是p的右子树时，将p左单旋，g右单旋，cur变黑，g变红

 当p是g的右子树，cur是p的左子树，p右单旋，g左单旋，p变黑，g变红

再看cur为红，p为红，g为黑，u不存在的情况，u不存在的情况更为简单：

当p是g的左子树，cur是p的右子树时， 将p左单旋，g右单旋，cur变黑，g变红

当p是g的右子树，cur是p的左子树，p右单旋就变成了情况二：

4.红黑树节点插入代码

  1. 	//插入
  2. 	pair<Node*, bool> Insert(const pair<K, V>& kv)
  3. 	{
  4. 		if (_root == nullptr)
  5. 		{
  6. 			_root = new Node(kv);
  7. 			_root->_col = BLACK;
  8. 			return make_pair(_root, true);
  9. 		}
  10.  
  11. 		//1.先看树中，kv是否存在
  12. 		Node* parent = nullptr;
  13. 		Node* cur = _root;
  14. 		while (cur)
  15. 		{
  16. 			if (cur->_kv.first < kv.first)
  17. 			{
  18. 				//kv比当前节点值大，向右走
  19. 				parent = cur;
  20. 				cur = cur->_right;
  21. 			}
  22. 			else if (cur->_kv.first > kv.first)
  23. 			{
  24. 				//kv比当前节点值小，向左走
  25. 				parent = cur;
  26. 				cur = cur->_left;
  27. 			}
  28. 			else
  29. 			{
  30. 				//kv和当前节点值相等，已存在，插入失败
  31. 				return make_pair(cur, false);
  32. 			}
  33. 		}
  34.  
  35. 		//2.走到这里，说明kv在树中不存在，需要插入kv，并且cur已经为空，parent已经是叶子节点了
  36. 		Node* newNode = new Node(kv);
  37. 		newNode->_col = RED;
  38. 		if (parent->_kv.first < kv.first)
  39. 		{
  40. 			//kv比parent值大，插入到parent的右边
  41. 			parent->_right = newNode;
  42. 			cur->_parent = parent;
  43. 		}
  44. 		else
  45. 		{
  46. 			//kv比parent值小，插入到parent的左边
  47. 			parent->_left = newNode;
  48. 			cur->_parent = parent;
  49. 		}
  50. 		cur = newNode;
  51.  
  52. 		//如果父亲存在，且父亲颜色为红就要处理
  53. 		while (parent && parent->_col == RED)
  54. 		{
  55. 			//关键看叔叔
  56. 			Node* grandfather = parent->_parent;
  57. 			if (parent == grandfather->_left)//父亲是祖父的左子树
  58. 			{
  59. 				Node* uncle = grandfather->_right;
  60. 				//情况一：叔叔存在且为红
  61. 				if (uncle->_col == RED)
  62. 				{
  63. 					parent->_col = uncle->_col = BLACK;
  64. 					grandfather->_col = RED;
  65.  
  66. 					//继续向上调整
  67. 					cur = grandfather;
  68. 					parent = cur->_parent;
  69. 				}
  70. 				else//情况二+情况三：叔叔不存在或叔叔存在且为黑
  71. 				{
  72. 					//情况二：单旋
  73. 					if (cur == parent->_left)
  74. 					{
  75. 						RotateR(grandfather);
  76. 						parent->_col = BLACK;
  77. 						grandfather->_col = RED;
  78. 					}
  79. 					else//情况三：双旋
  80. 					{
  81. 						RotateL(parent);
  82. 						RotateR(grandfather);
  83. 						cur->_col = BLACK;
  84. 						grandfather->_col = RED;
  85. 					}
  86. 					break;//插入结束
  87. 				}
  88. 			}
  89. 			else//父亲是祖父的右子树
  90. 			{
  91. 				Node* uncle = grandfather->_left;
  92. 				//情况一：叔叔存在且为红
  93. 				if (uncle && uncle->_col == RED)
  94. 				{
  95. 					parent->_col = uncle->_col = BLACK;
  96. 					grandfather->_col = RED;
  97.  
  98. 					//继续往上调整
  99. 					cur = grandfather;
  100. 					parent = grandfather->_parent;
  101. 				}
  102. 				else//情况二+情况三：叔叔不存在或叔叔存在且为黑
  103. 				{
  104. 					//情况二：单旋
  105. 					if (cur == parent->_right)
  106. 					{
  107. 						RotateL(grandfather);
  108. 						parent->_col = BLACK;
  109. 						grandfather->_col = RED;
  110. 					}
  111. 					else//情况三：双旋
  112. 					{
  113. 						RotateR(parent);
  114. 						RotateL(grandfather);
  115. 						cur->_col = BLACK;
  116. 						grandfather->_col = RED;
  117. 					}
  118. 					break;//插入结束
  119. 				}
  120. 			}
  121. 			
  122. 		}
  123. 		_root->_col = BLACK;
  124.  
  125. 		return make_pair(newNode, true);
  126. 	}

 五、红黑树查找

查找比较简单，递归向左走或向右走：

  1. 	//查找
  2. 	Node* Find(const K& key)
  3. 	{
  4. 		Node* cur = _root;
  5. 		while (cur)
  6. 		{
  7. 			if (cur->_kv.first < key)//key比当前节点小，就向右查找
  8. 			{
  9. 				cur = cur->_right;
  10. 			}
  11. 			else if (cur->_kv.first > key)//key比当前节点大，就向左查找
  12. 			{
  13. 				cur = cur->_left;
  14. 			}
  15. 			else//找到了
  16. 			{
  17. 				return cur;
  18. 			}
  19. 		}
  20. 		return nullptr;//空树，直接返回
  21. 	}

六、红黑树检查是否平衡

 检查是否平衡还是要用到递归子函数

（1）需要判断是否满足红黑树的4条性质

（2）计算最左路径上的黑色节点个数，递归路径时，需要计算该条路径上的黑色节点个数是否和最左路径上的节点个数相等

  1. 	bool _CheckBalance(Node* root, int blackNum, int count)
  2. 	{
  3. 		if (root == nullptr)
  4. 		{
  5. 			if (count != blackNum)
  6. 			{
  7. 				cout << "黑色节点数量不相等" << endl;
  8. 				return false;
  9. 			}
  10. 			return true;
  11. 		}
  12.  
  13. 		if (root->_col == RED && root->_parent->_col == RED)
  14. 		{
  15. 			cout << "存在连续红色节点" << endl;
  16. 			return false;
  17. 		}
  18.  
  19. 		if (root->_col == BLACK)
  20. 		{
  21. 			count++;
  22. 		}
  23.  
  24. 		return _CheckBalance(root->_left, blackNum, count)
  25. 			&& _CheckBalance(root->_right, blackNum, count);
  26. 	}
  27.  
  28. 	//检查是否平衡
  29. 	bool CheckBlance()
  30. 	{
  31. 		if (_root == nullptr)
  32. 		{
  33. 			return true;
  34. 		}
  35. 		
  36. 		if (_root->_col == RED)
  37. 		{
  38. 			cout << "根节点为红色" << endl;
  39. 			return false;
  40. 		}
  41.  
  42. 		//找最左路径做黑色节点数量参考值
  43. 		int blackNum = 0;
  44. 		Node* left = _root;
  45. 		while (left)
  46. 		{
  47. 			if (left->_col == BLACK)
  48. 			{
  49. 				blackNum++;
  50. 			}
  51. 			left = left->_left;
  52. 		}
  53.  
  54. 		int count = 0;
  55. 		return _CheckBlance(_root, blackNum, count);
  56. 	}

对于以下红黑树，递归过程如下：

七、红黑树遍历

遍历也很简单，中序递归遍历左子树和右子树：

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

八、红黑树验证 

  1. #include "RedBlackTree.h"
  2.  
  3. void TestRBTree()
  4. {
  5. 	//,1,3,5,15,7,16,14
  6. 	int a[] = { 4,2,6,1,3,5,15,7,16 };
  7. 	RBTree<int, int> t;
  8. 	for (auto e : a)
  9. 	{
  10. 		t.Insert(make_pair(e, e));
  11. 	}
  12.  
  13. 	t.InOrder();
  14. 	//cout << t.CheckBalance() << endl;
  15. }
  16.  
  17. int main()
  18. {
  19. 	TestRBTree();
  20. 	return 0;
  21. }

插入成功：

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号