• 【C++】AVL树的插入实现

    前言

            针对于前面所实现的搜索二叉树，其实我们会发现一些问题，就是可能会演化为单支树或者随便两支子树高度相差大。如果二叉树的结构是这样的话就不能保证查找效率高，因为只能将树保持为左右子树差不多的高度才可以保证查找效率。

            这样的搜索二叉树我们可以称之为平衡搜索二叉树。现在我们就开启其中一个实现树-AVL树，了解其插入方法即其平衡树调整的基本结构。

    上一篇C++博客~

    【C++】二叉搜索树_柒海啦的博客-CSDN博客

    目录​​​​​​​

    一、AVL树结构

    1.pair结构

    2.AVL结点结构

    AVL树结点结构：

    二、AVL树调节平衡

    1.控制平衡因子

    2.旋转调节

    左单旋：

    右单旋：

    左右双旋：

    右左双旋：

    三、AVL树代码实现

    1.AVL树结点

    2.AVL树插入

    左单旋

    右单旋

    右左双旋

    左右双旋

    四、AVL树的验证

    五、综合代码

    一、AVL树结构

            在一开始的二叉树搜索树中，我们会发现有两个模型：key和key-value模型。对于key-value模型，按照我们上次实现搜索二叉树的思路，就会直接在结点结构里面加上value变量存key所对应的value值。

            但是，这里我们使用一种键值对的结构来代替上述key-value。

    1.pair结构

    1. 	template<class K, class V>  // 简单的一个模板类
    2. 	struct pair
    3. 	{
    4. 		K frist;
    5. 		V second;
    6.  
    7. 		pair()
    8. 			:frist(K())
    9. 			,second(V())
    10. 		{}
    11. 		pair(const K& k, const V& v)
    12. 			:frist(k)
    13. 			,second(v)
    14. 		{}
    15. 	};

            上面是我模仿pair的基本结构自己写的简单代码。可以发现，这是一个模板类，需要给定类型，其中成员frist存储k，second成员存v。库中同样存在实现，放在std命名空间下的：

     

             可以看到，上面每次构造一个pair对象都要传入类型，很烦，以后利用此结构进行多次插入的时候就很麻烦。那么能不能让编译器帮我们解决呢？也就是自动识别类型：

             我们可以发现，make_pair本身是一个函数，根据我们传入的参数自动的实例化了一个pair对象然后传出来。这样就会方便很多。

            在之后的AVL树结构中（在先前的二叉树搜索树中实现key和key-value模型均利用key进行比较），我们就可以利用pair的成员first即存储的key值进行比较。

            现在回到正题。既然数据是由pair结构来进行存储键值对，那么一个AVL树的结点内的结构该如何定义呢？

    2.AVL结点结构

            首先搜索二叉树的结构不能忘掉：Node* left，right分别指向左右子树。data使用pair。就用此结构能完成对平衡的调节吗？

            我们其实从这里就可以探讨一下所谓平衡：基础的二叉搜索树之所以会出现那样的问题，根本在于在插入的时候并没有关注左右子树的高度差，其次当出现一边树比另一边树高的时候，应该将低的那一边树的结点给旋转下去。

             可以看到上面所给的二叉树例子。当一个二叉树子树过长的时候，我们进行适当的旋转就可以达到降低高度的目的。所以针对高度差和旋转问题，我实现AVL树的时候引入的结构是比较好实现的平衡因子和三叉链（Node* parent）。

    AVL树结点结构：

     pair：键值对容器。

    结点指针：三叉链-分别指向左子树结点，右子树结点，父结点。

    平衡因子：控制左右子树高度差。（利用规则，每次新增在一个结点右++，左就--。初始化为0）

            那么，现在的关键在于，我们要如何控制变化平衡因子的规则，在何时进行旋转，并且对于的平衡因子也要进行变化。

    二、AVL树调节平衡

            实际上，调节平衡自然是要在插入新的元素中要做的事情（删除也需要，这里只讲AVL树基本构造，所以省去了删除操作）。

            现在我们在原本二叉树结点的结构上定义了AVL树结点的结构：三叉链方便控制旋转，平衡因子检查左右子树高度。

            那么现在我们为了控制整个树的平衡，AVL树的规则为任意的左右子树高度差不超过1。这样的话，现在平衡因子的控制思路为：左子树插入为--，右子树插入为++。如果两子树高度差超过1，就需要旋转调节平衡。

            我引入例子来帮助理解我们理解AVL树是如何调节平衡的：

    比如我们去插入如下数：4, 2, 6, 1, 3, 5, 15, 7, 16, 14（此时均代表key值）

            在一开始从4开始到16插入按照搜索二叉树来走都没有违反AVL树的规则。

      

             一旦插入14，我们发现此时的结构发生了变化

             可以看到由于新插入的结点影响，导致右子树比左子树高。而此时根据平衡因子规则6结点的平衡因子就为2,15结点为-1。此时就该进行旋转：

    1.控制平衡因子

            上面只是对一个实例进行初步的认知，总而言之，我们控制平衡因子的大致方法：

    1.新结点在当前结点左子树插入就平衡因子-1，在右子树插入平衡因子就+1。

    2.当前结点新增后平衡因子变为1或者-1，就要向上调整父结点的平衡因子。

    3.如果当前结点变为2或者-2，说明右子树或者左子树高度差破坏了不超过1的AVL数规则，此时就要进行旋转调节平衡因子达到平衡的效果。

            问题的关键在于第3点，当平衡因子的绝对值超过1的时候，我们就需要对多种抽象情况进行旋转调节。

    2.旋转调节

            根据多种二叉树进行分析，我具象成了如下几种的插入情况：

    左单旋：

    分析：

    旋转原因：

            观察图1，原本结构p结点平衡因子为1，R结点平衡因子为0。此时在R结点的右子树插入新结点，导致R结点平衡因子变为1，继续向上导致P结点平衡因子变为2，引发旋转。

    旋转过程：

            由于此时右边层数高于左边层数，那么此时只需要将p和其左子树压下去即可。根据二叉搜索树规则，因为其均小于右子树（左小，右大），因为此时R的右子树（c）增加了一个长度，那么可以将p也视为在b（R的左子树）增加一个长度，具体操作为p作为R的新左子树头结点，将b接在p的右子树。此时就左旋转形成图2。

    旋转结果：

            R的平衡因子原本插入后变为1，p变为2。旋转后R和p的平衡因子均变为0。此时无需向上调整。（子树只要不变为1或者-1也就是没有增加高度就不会向上调整）但是注意p为根结点的话就要特别处理。

    注：

            h表示子树长度，并且h>=0。R和P均为具体的结点，abc只是表示这一部分的子树。

    右单旋：

    分析：

    旋转原因：

            观察图1，原本结构p结点平衡因子为-1，L结点平衡因子为0。此时在L结点的左子树插入新结点，导致L结点平衡因子变为-1，继续向上导致P结点平衡因子变为-2，引发旋转。

    旋转过程：

            由于此时左边层数高于右边层数，那么此时只需要将p和其右子树压下去即可。根据二叉搜索树规则，因为其均大于左子树（左小，右大），因为此时L的左子树（a）增加了一个长度，那么可以将p也视为在b（L的右子树）增加一个长度，具体操作为p作为L的新右子树头结点，将b接在p的左子树。此时就右旋转形成图2。

    旋转结果：

            L的平衡因子原本插入后变为-1，p变为-2。旋转后L和p的平衡因子均变为0。此时无需向上调整。（子树只要不变为1或者-1也就是没有增加高度就不会向上调整）但是注意p为根结点的话就要特别处理。

    注：

            h表示子树长度，并且h>=0。L和P均为具体的结点，abc只是表示这一部分的子树。

    左右双旋：

    ​​​​​​​

    分析：

    旋转原因：

            实际上是在右单旋的场景下，对L结点的右子树b进行插入。由于此时插入的是中间位置（无论是图1中的c还是d子树，上述以插入c举例--注意插入c和d虽然和旋转无关但是和平衡因子有关）所以单纯的右旋转只会转化为对称的一个高度差超出1的二叉搜索树而已。此时将LR变化为-1（从d新增变为1），L变成1，p结点平衡因子变为-2，从而引发左右双旋。

    旋转过程：

            既然右旋转不行，我们先单独看图1中根结点的左子树。由于此时是LR结点的子树高，我们此时想要降低高度目的也就是想将一个结点旋转下去，可以针对于L结点，将其进行左单旋变成图2.此时图中的平衡因子值为之前插入时变化的，并没有修改。

            此时就可以演变为LR结点的左子树新增结点，此时再将P结点进行右单旋即可。如图三。

    旋转结果：

            旋转完后此时就发现是一个平衡树了。对应的将L的平衡因子修改为0，p的平衡因子修改为1（注意这两个平衡因子和一开始LR对哪个子树插入有关）LR平衡因子肯定为0。同样的不需要向上调整了，这里也需要注意h为0的情况，这种情况类似的进行分析。（如果h为0，此时的LR就是新增结点）

    注：

            h表示子树长度，并且h>=0。L、LR和P均为具体的结点，abcd只是表示这一部分的子树。

    右左双旋：

    分析：

    旋转原因：

            实际上是在左单旋的场景下，对R结点的左子树b进行插入。由于此时插入的是中间位置（无论是图1中的c还是d子树，上述以插入d举例--注意插入c和d虽然和旋转无关但是和平衡因子有关）所以单纯的左旋转只会转化为对称的一个高度差超出1的二叉搜索树而已。此时将RL变化为1（从c新增变为-1），R变成-1，p结点平衡因子变为2，从而引发右左双旋。

    旋转过程：

            既然左旋转不行，我们先单独看图1中根结点的右子树。由于此时是RL结点的子树高，我们此时想要降低高度目的也就是想将一个结点旋转下去，可以针对于R结点，将其进行右单旋变成图2.此时图中的平衡因子值为之前插入时变化的，并没有修改。

            此时就可以演变为RL结点的右子树新增结点，此时再将P结点进行左单旋即可。如图三。

    旋转结果：

            旋转完后此时就发现是一个平衡树了。对应的将R的平衡因子修改为0，p的平衡因子修改为1（注意这两个平衡因子和一开始RL对哪个子树插入有关）RL平衡因子肯定为0。同样的不需要向上调整了，这里也需要注意h为0的情况，这种情况类似的进行分析。（如果h为0，此时的RL就是新增结点）

    注：

            h表示子树长度，并且h>=0。R、RL和P均为具体的结点，abcd只是表示这一部分的子树。

            好了，了解了插入进行旋转平衡搜索二叉树后，我们直接用代码进行实操吧~ 

    三、AVL树代码实现

    1.AVL树结点

            三叉链、pair、平衡因子。存在pair就需要两个模板参数：（注意给一个pair参数的构造函数）

    1. template<class K, class V>  // 用来实例化pair的参数
    2. struct AVLTreeNode  // AVL因为需要旋转，所以需要靠三叉链进行完成 并且加上平衡因子
    3. {
    4. 	AVLTreeNode* left;
    5. 	AVLTreeNode* right;
    6. 	AVLTreeNode* parent;
    7.  
    8. 	pair kv;
    9. 	int bf;  // 重要成员-平衡因子
    10.  
    11. 	AVLTreeNode(const pair& data)
    12. 		:left(nullptr)
    13. 		,right(nullptr)
    14. 		,parent(nullptr)
    15. 		,kv(data)
    16. 		,bf(0)
    17. 	{}
    18. };

    2.AVL树插入

             首先AVL树类的基本结构搭建起来：

    1. template<class K, class V>
    2. class AVLTree
    3. {
    4. public:
    5. 	typedef AVLTreeNode Node;
    6.  
    7. // ......
    8.  
    9. private:
    10. 	Node* _root = nullptr;  // 存一个根结点即可
    11. };

            首先按照搜索二叉树那样去新增结点：

    1. // 插入 
    2. 	bool insert(const pair& data)
    3. 	{
    4. 		// 首先按照搜索二叉树走，右边插入此结点平衡因子++，左边插入--。此时检查平衡因子
    5. 		if (_root == nullptr)  // 如果第一次插入
    6. 		{
    7. 			_root = new Node(data);
    8. 			return true;
    9. 		}
    10.  
    11. 		Node* p = nullptr;
    12. 		Node* c = _root;
    13. 		while (c)
    14. 		{
    15. 			if (c->kv.first > data.first)
    16. 			{
    17. 				p = c;
    18. 				c = c->left;
    19. 			}
    20. 			else if (c->kv.first < data.first)
    21. 			{
    22. 				p = c;
    23. 				c = c->right;
    24. 			}
    25. 			else  // 不允许数据冗余，返回false
    26. 			{
    27. 				return false;
    28. 			}
    29. 		}
    30.  
    31. 		c = new Node(data);
    32. 		if (p->kv.first > c->kv.first)
    33. 		{
    34. 			p->left = c;
    35. 		}
    36. 		else
    37. 		{
    38. 			p->right = c;
    39. 		}
    40. 		c->parent = p;
    41.  
    42. // 调节平衡因子
    43. // ......
    44.     }

             此时c为新增结点，p就要去修改平衡因子。和之前的说的那样，如果是左就--，右就++，如果此时p的平衡因子为1或者-1就要继续，为0结束，为2或者-2就要进行旋转。那么以p结点为循环进行：

    1. 		while (p)
    2. 		{
    3. 			if (p->left == c)
    4. 			{
    5. 				p->bf--;
    6. 			}
    7. 			else
    8. 			{
    9. 				p->bf++;
    10. 			}
    11.  
    12. 			if (p->bf == 0)
    13. 			{
    14. 				return true;  // 此时子树没有增长，不用往上调整了
    15. 			}
    16. 			else if (abs(p->bf) == 1)  // 子树增长，上面的平衡因子需要变化
    17. 			{
    18. 				c = p;
    19. 				p = p->parent;
    20. 			}
    21. 			else if (abs(p->bf) == 2)  // 不符合AVL树的性质，需要进行旋转
    22. 			{
    23.             // ......
    24.             }
    25. 			else  // 不可能出现，出现了说明之前的结构就不对，检查上述代码
    26. 			{
    27. 				assert(false);
    28. 			}
    29. 		}
    30.  
    31. 		return true;

            结合上面我们所讨论的旋转的四种情况，根据此时p结点和c结点的平衡因子进行判断分为如下几种情况：

    1. 				//左单旋 - 最右增加
    2. 				if (p->bf == 2 && c->bf == 1)
    3. 				{
    4. 					RotateL(p);
    5. 				}
    6. 				else if (p->bf == -2 && c->bf == -1)  // 右单旋 - 最左增加
    7. 				{
    8. 					RotateR(p);
    9. 				}
    10. 				else if (p->bf == 2 && c->bf == -1)  //右左双旋
    11. 				{
    12. 					RotateRL(p);
    13. 				}
    14. 				else  // 左右双旋
    15. 				{
    16. 					RotateLR(p);
    17. 				}
    18. 				break;

            针对每个旋转实现也如下：（将其定义为私有方法）

    左单旋

    1. void RotateL(Node* p)  // 左单旋
    2. 	{
    3. 		Node* subR = p->right;
    4. 		Node* subRL = subR->left;  // 小心此结点可能为空
    5.  
    6. 		if (subRL) subRL->parent = p;
    7. 		p->right = subRL;
    8. 		Node* pp = p->parent;  // 记录一下上一层结点
    9. 		p->parent = subR;
    10. 		subR->left = p;
    11. 		if (pp == nullptr)  // 如果p为根结点
    12. 		{
    13. 			subR->parent = nullptr;
    14. 			_root = subR;  // 别忘了修改属性
    15. 		}
    16. 		else
    17. 		{
    18. 			if (pp->left == p) pp->left = subR;
    19. 			else pp->right = subR;
    20. 			subR->parent = pp;
    21. 		}
    22. 		// 修改因子
    23. 		p->bf = subR->bf = 0;
    24. 	}

    右单旋

    1. 	void RotateR(Node* p)  // 右单旋
    2. 	{
    3. 		Node* subL = p->left;
    4. 		Node* subLR = subL->right;  // 小心此结点可能为空
    5.  
    6. 		if (subLR) subLR->parent = p;
    7. 		p->left = subLR;
    8. 		Node* pp = p->parent;  // 记录一下上一层结点
    9. 		p->parent = subL;
    10. 		subL->right = p;
    11. 		if (pp == nullptr)  // 如果p为根结点
    12. 		{
    13. 			subL->parent = nullptr;
    14. 			_root = subL;  // 别忘了修改属性
    15. 		}
    16. 		else
    17. 		{
    18. 			if (pp->left == p) pp->left = subL;
    19. 			else pp->right = subL;
    20. 			subL->parent = pp;
    21. 		}
    22. 		// 修改因子
    23. 		p->bf = subL->bf = 0;
    24. 	}

    右左双旋

    1. 	void RotateRL(Node* p)  // 右左双旋
    2. 	{
    3. 		Node* subR = p->right;
    4. 		Node* subRL = subR->left; // 双旋变化的三个结点
    5. 		int bf = subRL->bf;
    6.  
    7. 		RotateR(p->right);
    8. 		RotateL(p);
    9. 		// 旋好后注意平衡因子
    10.  
    11. 		subRL->bf = 0;  // 双旋后的所在子树头结点，一定为0
    12. 		if (bf == 0)
    13. 		{
    14. 			subR->bf = 0;
    15. 			p->bf = 0;
    16. 		}
    17. 		else if (bf == 1)
    18. 		{
    19. 			//一开始subRL的右子树新增 ，此时到了subR的左子树
    20. 			subR->bf = 0;
    21. 			p->bf = -1;
    22. 		}
    23. 		else if (bf == -1)
    24. 		{
    25. 			p->bf = 0;
    26. 			subR->bf = 1;
    27. 		}
    28. 		else
    29. 		{// 理论上不存在此种情况，出现报错检查前面的问题
    30. 			assert(false);
    31. 		}
    32. 	}

    左右双旋

    1. 	void RotateLR(Node* p)  // 左右双旋
    2. 	{
    3. 		Node* subL = p->left;
    4. 		Node* subLR = subL->right; // 双旋变化的三个结点
    5. 		int bf = subLR->bf;
    6.  
    7. 		RotateL(p->left);
    8. 		RotateR(p);
    9. 		// 旋好后注意平衡因子
    10.  
    11. 		subLR->bf = 0;  // 双旋后的所在子树头结点，一定为0
    12. 		if (bf == 0)  // 自己为新增结点 h为0
    13. 		{
    14. 			p->bf = 0;
    15. 			subL->bf = 0;
    16. 		}
    17. 		else if (bf == 1)
    18. 		{
    19. 			p->bf = 0;
    20. 			subL->bf = -1;
    21. 		}
    22. 		else if (bf == -1)
    23. 		{
    24. 			subL->bf = 0;
    25. 			p->bf = 1;
    26. 		}
    27. 		else
    28. 		{// 理论上不存在此种情况，出现报错检查前面的问题
    29. 			assert(false);
    30. 		}
    31. 	}

    四、AVL树的验证

            上述插入AVL树的大致结构完成了。那么我们真正的去构造AVL树的时候如何去判断其是不是呢？

            首先判断其中序是否满足有序（二叉搜索树）

            其次判断每个结点对应的左右子树高度差是否和对应的结点平衡因子相等或者绝对值超过1了，代码简单实现如下（递归实现）：

    1. 	bool IsBalanceTree()
    2. 	{  // 检查是否是平衡二叉树
    3. 		return _isBalanceTree(_root);
    4. 	}
    5. private:
    6. 	bool _isBalanceTree(Node* root)
    7. 	{
    8. 		if (root == nullptr) return true;
    9. 		int leftheight = isheight(root->left);
    10. 		int rightheight = isheight(root->right);
    11. 		int n = rightheight - leftheight;
    12. 		if (n != root->bf || abs(n) > 1) return false;
    13. 		return _isBalanceTree(root->left) && _isBalanceTree(root->right);
    14. 	}
    15.  
    16. 	int isheight(Node* root)
    17. 	{
    18. 		if (root == nullptr) return 0;
    19. 		int left = isheight(root->left);
    20. 		int right = isheight(root->right);
    21. 		return left > right ? left + 1 : right + 1;
    22. 	}

    五、综合代码

            综上，简单实现AVL树结构的代码如下：（测试代码自己写哦~）

    1. // AVL树 - 二叉搜索树优化，控制树的左右高度差不超过1 - 本版本利用平衡因子进行实现
    2. template<class K, class V>  // 用来实例化pair的参数
    3. struct AVLTreeNode  // AVL因为需要旋转，所以需要靠三叉链进行完成 并且加上平衡因子
    4. {
    5. 	AVLTreeNode* left;
    6. 	AVLTreeNode* right;
    7. 	AVLTreeNode* parent;
    8.  
    9. 	pair kv;
    10. 	int bf;  // 重要成员-平衡因子
    11.  
    12. 	AVLTreeNode(const pair& data)
    13. 		:left(nullptr)
    14. 		,right(nullptr)
    15. 		,parent(nullptr)
    16. 		,kv(data)
    17. 		,bf(0)
    18. 	{}
    19. };
    20.  
    21. template<class K, class V>
    22. class AVLTree
    23. {
    24. public:
    25. 	typedef AVLTreeNode Node;
    26. 	AVLTree() = default;  // 编译器必须生成默认构造
    27.  
    28. 	// 查找
    29. 	bool find(const K& k)
    30. 	{
    31. 		Node* c = _root;
    32. 		while (c)
    33. 		{
    34. 			if (c->kv.first > k)
    35. 			{
    36. 				c = c->left;
    37. 			}
    38. 			else if (c->kv.first < k)
    39. 			{
    40. 				c = c->right;
    41. 			}
    42. 			else
    43. 			{
    44. 				return true;
    45. 			}
    46. 		}
    47. 		return false;
    48. 	}
    49.  
    50. 	// 插入 
    51. 	bool insert(const pair& data)
    52. 	{
    53. 		// 首先按照搜索二叉树走，右边插入此结点平衡因子++，左边插入--。此时检查平衡因子
    54. 		if (_root == nullptr)  // 如果第一次插入
    55. 		{
    56. 			_root = new Node(data);
    57. 			return true;
    58. 		}
    59.  
    60. 		Node* p = nullptr;
    61. 		Node* c = _root;
    62. 		while (c)
    63. 		{
    64. 			if (c->kv.first > data.first)
    65. 			{
    66. 				p = c;
    67. 				c = c->left;
    68. 			}
    69. 			else if (c->kv.first < data.first)
    70. 			{
    71. 				p = c;
    72. 				c = c->right;
    73. 			}
    74. 			else  // 不允许数据冗余，返回false
    75. 			{
    76. 				return false;
    77. 			}
    78. 		}
    79.  
    80. 		c = new Node(data);
    81. 		if (p->kv.first > c->kv.first)
    82. 		{
    83. 			p->left = c;
    84. 		}
    85. 		else
    86. 		{
    87. 			p->right = c;
    88. 		}
    89. 		c->parent = p;
    90.  
    91.  
    92. 		// 调节平衡因子
    93. 		while (p)
    94. 		{
    95. 			if (p->left == c)
    96. 			{
    97. 				p->bf--;
    98. 			}
    99. 			else
    100. 			{
    101. 				p->bf++;
    102. 			}
    103.  
    104. 			if (p->bf == 0)
    105. 			{
    106. 				return true;  // 此时子树没有增长，不用往上调整了
    107. 			}
    108. 			else if (abs(p->bf) == 1)  // 子树增长，上面的平衡因子需要变化
    109. 			{
    110. 				c = p;
    111. 				p = p->parent;
    112. 			}
    113. 			else if (abs(p->bf) == 2)  // 不符合AVL树的性质，需要进行旋转
    114. 			{
    115. 				// 大致分3种情况，右单旋，左单旋，双旋。双旋分为先左单旋、再右单旋；先右单旋，再左单旋。根据抽象出来的bf进行决定
    116. 				//左单旋 - 最右增加
    117. 				if (p->bf == 2 && c->bf == 1)
    118. 				{
    119. 					RotateL(p);
    120. 				}
    121. 				else if (p->bf == -2 && c->bf == -1)  // 右单旋 - 最左增加
    122. 				{
    123. 					RotateR(p);
    124. 				}
    125. 				else if (p->bf == 2 && c->bf == -1)  //右左双旋
    126. 				{
    127. 					RotateRL(p);
    128. 				}
    129. 				else  // 左右双旋
    130. 				{
    131. 					RotateLR(p);
    132. 				}
    133. 				break;
    134. 			}
    135. 			else  // 不可能出现，出现了说明之前的结构就不对，检查上述代码
    136. 			{
    137. 				assert(false);
    138. 			}
    139. 		}
    140.  
    141. 		return true;
    142. 	}
    143.  
    144. 	void order()
    145. 	{
    146. 		// 非递归中序遍历
    147. 		std::stack s;
    148. 		Node* c = _root;
    149.  
    150. 		while (c || !s.empty())
    151. 		{
    152. 			if (c)
    153. 			{
    154. 				s.push(c);
    155. 				c = c->left;
    156. 			}
    157. 			else
    158. 			{
    159. 				c = s.top();
    160. 				cout << c->kv.first << ":" << c->kv.second << " ";
    161. 				c = c->right;
    162. 				s.pop();
    163. 			}
    164. 		}
    165. 		std::cout << endl;
    166. 	}
    167.  
    168. 	bool IsBalanceTree()
    169. 	{  // 检查是否是平衡二叉树
    170. 		return _isBalanceTree(_root);
    171. 	}
    172. private:
    173. 	bool _isBalanceTree(Node* root)
    174. 	{
    175. 		if (root == nullptr) return true;
    176. 		int leftheight = isheight(root->left);
    177. 		int rightheight = isheight(root->right);
    178. 		int n = rightheight - leftheight;
    179. 		if (n != root->bf || abs(n) > 1) return false;
    180. 		return _isBalanceTree(root->left) && _isBalanceTree(root->right);
    181. 	}
    182.  
    183. 	int isheight(Node* root)
    184. 	{
    185. 		if (root == nullptr) return 0;
    186. 		int left = isheight(root->left);
    187. 		int right = isheight(root->right);
    188. 		return left > right ? left + 1 : right + 1;
    189. 	}
    190.  
    191. 	void RotateL(Node* p)  // 左单旋
    192. 	{
    193. 		Node* subR = p->right;
    194. 		Node* subRL = subR->left;  // 小心此结点可能为空
    195.  
    196. 		if (subRL) subRL->parent = p;
    197. 		p->right = subRL;
    198. 		Node* pp = p->parent;  // 记录一下上一层结点
    199. 		p->parent = subR;
    200. 		subR->left = p;
    201. 		if (pp == nullptr)  // 如果p为根结点
    202. 		{
    203. 			subR->parent = nullptr;
    204. 			_root = subR;  // 别忘了修改属性
    205. 		}
    206. 		else
    207. 		{
    208. 			if (pp->left == p) pp->left = subR;
    209. 			else pp->right = subR;
    210. 			subR->parent = pp;
    211. 		}
    212. 		// 修改因子
    213. 		p->bf = subR->bf = 0;
    214. 	}
    215.  
    216. 	void RotateR(Node* p)  // 右单旋
    217. 	{
    218. 		Node* subL = p->left;
    219. 		Node* subLR = subL->right;  // 小心此结点可能为空
    220.  
    221. 		if (subLR) subLR->parent = p;
    222. 		p->left = subLR;
    223. 		Node* pp = p->parent;  // 记录一下上一层结点
    224. 		p->parent = subL;
    225. 		subL->right = p;
    226. 		if (pp == nullptr)  // 如果p为根结点
    227. 		{
    228. 			subL->parent = nullptr;
    229. 			_root = subL;  // 别忘了修改属性
    230. 		}
    231. 		else
    232. 		{
    233. 			if (pp->left == p) pp->left = subL;
    234. 			else pp->right = subL;
    235. 			subL->parent = pp;
    236. 		}
    237. 		// 修改因子
    238. 		p->bf = subL->bf = 0;
    239. 	}
    240.  
    241. 	void RotateRL(Node* p)  // 右左双旋
    242. 	{
    243. 		Node* subR = p->right;
    244. 		Node* subRL = subR->left; // 双旋变化的三个结点
    245. 		int bf = subRL->bf;
    246.  
    247. 		RotateR(p->right);
    248. 		RotateL(p);
    249. 		// 旋好后注意平衡因子
    250.  
    251. 		subRL->bf = 0;  // 双旋后的所在子树头结点，一定为0
    252. 		if (bf == 0)
    253. 		{
    254. 			subR->bf = 0;
    255. 			p->bf = 0;
    256. 		}
    257. 		else if (bf == 1)
    258. 		{
    259. 			//一开始subRL的右子树新增 ，此时到了subR的左子树
    260. 			subR->bf = 0;
    261. 			p->bf = -1;
    262. 		}
    263. 		else if (bf == -1)
    264. 		{
    265. 			p->bf = 0;
    266. 			subR->bf = 1;
    267. 		}
    268. 		else
    269. 		{// 理论上不存在此种情况，出现报错检查前面的问题
    270. 			assert(false);
    271. 		}
    272. 	}
    273.  
    274. 	void RotateLR(Node* p)  // 左右双旋
    275. 	{
    276. 		Node* subL = p->left;
    277. 		Node* subLR = subL->right; // 双旋变化的三个结点
    278. 		int bf = subLR->bf;
    279.  
    280. 		RotateL(p->left);
    281. 		RotateR(p);
    282. 		// 旋好后注意平衡因子
    283.  
    284. 		subLR->bf = 0;  // 双旋后的所在子树头结点，一定为0
    285. 		if (bf == 0)  // 自己为新增结点 h为0
    286. 		{
    287. 			p->bf = 0;
    288. 			subL->bf = 0;
    289. 		}
    290. 		else if (bf == 1)
    291. 		{
    292. 			p->bf = 0;
    293. 			subL->bf = -1;
    294. 		}
    295. 		else if (bf == -1)
    296. 		{
    297. 			subL->bf = 0;
    298. 			p->bf = 1;
    299. 		}
    300. 		else
    301. 		{// 理论上不存在此种情况，出现报错检查前面的问题
    302. 			assert(false);
    303. 		}
    304. 	}
    305. private:
    306. 	Node* _root = nullptr;  // 存一个根结点即可
    307. };

            欢迎大佬补充~未完待续~~~

  • 相关阅读:
    ref、reactive、toRef、toRefs
    【0107】为什么二进制文件不显示为 0 和 1？
    数据湖是什么？数据湖的关键技术（二）
    java如何将字符串转换为json格式字符串呢？
    CGAL4.4+VC2008编译
    Camera API2使用流程分析
    【牛客 - 剑指offer】JZ4 二维数组中的查找 Java实现
    C/C++面试高频知识点八股文
    java后端调用接口Basic auth认证
    必知必会的22种设计模式（GO语言）
  • 原文地址：https://blog.csdn.net/weixin_61508423/article/details/127761743