• c++——AVL树

    目录

    一. AVL树的概念

    二. AVL树节点的定义

    三. AVL树的插入（重点）

    四. AVL树的旋转

    1.新节点插入较高右子树的右侧——左单旋

    2. 新节点插入较高左子树的左侧——右单旋

    3. 新节点插入较高左子树的右侧——左右双旋

    4. 新节点插入较高右子树的左侧——右左双旋

    五. AVL树的验证

    五. AVL树的性能

    六. AVL树的删除（了解向）

    七. AVL树的完整实现代码

    一. AVL树的概念

    二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。

    因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年发明了一种解决上述问题的方法：

    当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

    由此，该树被称为AVL树，即两位科学家名字的第一个字母。

    一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

    • 它的左右子树都是AVL树
    • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

    如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在

    O(logN)，搜索时间复杂度O(logN)。

    二. AVL树节点的定义

    实现的是kv结构：

    1. template<class K, class V>
    2. struct AVLTreeNode
    3. {
    4. 	pair _kv;
    5. 	AVLTreeNode* _left;
    6. 	AVLTreeNode* _right;
    7. 	AVLTreeNode* _parent;
    8.  
    9. 	int _bf;//平衡因子
    10. 	//AVL树并没有规定必须要选择设计平衡因子，只是一个实现的选择，方便控制
    11.  
    12. 	//构造函数
    13. 	AVLTreeNode(const pair& kv)
    14. 		:_kv(kv)
    15. 		, _left(nullptr)
    16. 		, _right(nullptr)
    17. 		, _parent(nullptr)
    18. 		, _bf(0)
    19. 	{}
    20.  
    21. };

    三. AVL树的插入（重点）

    AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。AVL树的插入过程可以分为两步：

    1. 按照二叉搜索树的方式插入新节点
    2. 调整节点的平衡因子

    按二叉搜索树的方式插入新节点，规则和二叉搜索一致

    1.     bool insert(const pair& kv)
    2. 	{
    3. 		if (_root == nullptr)
    4. 		{
    5. 			_root = new Node(kv);
    6. 			_root->_bf = 0;
    7. 			return true;
    8. 		}
    9.  
    10. 		//遍历查找插入节点
    11. 		Node* parent = nullptr;
    12. 		Node* cur = _root;
    13. 		while (cur != nullptr)
    14. 		{
    15. 			parent = cur;
    16. 			if (cur->_kv.first < kv.first)
    17. 				cur = cur->_right;
    18. 			else if (cur->_kv.first > kv.first)
    19. 				cur = cur->_left;
    20. 			else
    21. 				return false;
    22. 		}
    23.  
    24. 		//将节点插入树中
    25. 		cur = new Node(kv);
    26. 		if (parent->_kv.first > kv.first)
    27. 			parent->_left = cur;
    28. 		else
    29. 			parent->_right = cur;
    30. 		//将新插入节点的_parent被parent赋值
    31. 		cur->_parent = parent;
    32.  
    33. 		//平衡二叉搜索树
    34. 		while (parent != nullptr)
    35. 		{
    36. 			//更新父节点的平衡因子
    37. 			if (parent->_left == cur)
    38. 				parent->_bf--;
    39. 			else
    40. 				parent->_bf++;
    41.  
    42. 			//判断是否需要继续更新
    43. 			//1或-1说明高度变了，需要继续更新祖先节点的平衡因子
    44. 			if (parent->_bf == 1 || parent->_bf == -1)
    45. 			{
    46. 				cur = cur->_parent;
    47. 				parent = parent->_parent;
    48. 			}
    49. 			//0说明平衡了，不需要继续往上更新
    50. 			else if (parent->_bf == 0)
    51. 			{
    52. 				break;
    53. 			}
    54. 			//2和-2，不符合规则，需要旋转
    55. 			else if (parent->_bf == 2 || parent->_bf == -2)
    56. 			{
    57. 				//右边高，左单旋
    58. 				if (parent->_bf == 2 && cur->_bf == 1)
    59. 					RotateL(parent);
    60. 				//左边高右单旋
    61. 				else if (parent->_bf == -2 && cur->_bf == -1)
    62. 					RotateR(parent);
    63. 				//先
    64. 				else if (parent->_bf == -2 && cur->_bf == 1)
    65. 					RotateLR(parent);
    66. 				else if (parent->_bf == 2 && cur->_bf == -1)
    67. 					RotateRL(parent);
    68.  
    69. 				// 旋转完成后，整棵树已经是平衡搜索二叉树，跳出循环
    70. 				break;
    71. 			}
    72. 			else
    73. 			{
    74. 				//走到这说明这颗二叉树本来就有子树不满足平衡二叉树
    75. 				assert(false);
    76. 			}
    77.  
    78. 		}
    79.  
    80. 	}

    新节点插入后，AVL树的平衡性可能会遭到破坏，需要更新平衡因子，并检测是否破坏了AVL树的平衡性：

    在cur位置插入后，parent的平衡因子一定需要调整，在插入之前，parent的平衡因子分为三种情况：-1，0，1，分以下两种情况：

    1. cur插入到parent的左侧，parent的平衡因子-1
    2. cur插入到parent的右侧，parent的平衡因子+1

    做完上述操作parent的平衡因子可能有三种情况：0，正负1，正负2

    1. 如果parent的平衡因子为0，说明插入前parent的平衡因子为正负1，插入后被调整成0，满足AVL树的性质，插入成功
    2. parent的平衡因子为正负1，说明插入前parent的平衡因子一定为0，插入后被更新成正负1，以parent为根的树的高度增加，继续向上更新平衡因子
    3. parent的平衡因子为正负2，parent的平衡因子违反平衡树的性质，需要进行旋转处理
    1. //更新平衡因子
    2. 		while (parent != nullptr)
    3. 		{
    4. 			//更新父节点的平衡因子
    5. 			if (parent->_left == cur)
    6. 				parent->_bf--;
    7. 			else
    8. 				parent->_bf++;
    9.  
    10. 			//判断是否需要继续更新
    11. 			//1或-1说明高度变了，需要继续更新祖先节点的平衡因子
    12. 			if (parent->_bf == 1 || parent->_bf == -1)
    13. 			{
    14. 				cur = cur->_parent;
    15. 				parent = parent->_parent;
    16. 			}
    17. 			//0说明平衡了，不需要继续往上更新
    18. 			else if (parent->_bf == 0)
    19. 			{
    20. 				break;
    21. 			}
    22. 			//2和-2，不符合规则，需要旋转
    23. 			else if (parent->_bf == 2 || parent->_bf == -2)
    24. 			{
    25. 				//进行旋转处理
    26. 			}
    27. 			else
    28. 			{
    29. 				//走到这说明这颗二叉树本来就有子树不满足平衡二叉树
    30. 				assert(false);
    31. 			}
    32.  
    33. 		}

    四. AVL树的旋转

    如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构， 使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：

    1. 左单旋
    2. 右单旋
    3. 左右双旋
    4. 右左双旋

    旋转时需要始终记住旋转的原则：

    1. 保持搜索树的规则
    2. 子树变平衡

    1.新节点插入较高右子树的右侧——左单旋

    当插入到树中的数据如果为一个升序的数组，二叉搜索树会退化成一个只有右子树的单支树，效率大幅度下降，此时就会需要使用到左单旋对二叉搜索树进行平衡调整。

    先看下面的几个插入：

    当新增的节点如上图所示，新增节点为60的右节点时，此时就会违反平衡树的规则，右子树的右侧较高，需要进行左单旋。

    左单旋的方式：

    以30为旋转点，将60的左子树给30的右子树，30变成60的左子树

    就变成了第三幅图的样子。

    当新增节点为60右节点的右节点时，此时会违反平衡树的规则，右子树的右侧较高，需要进行左单旋。

    左单旋的方式：
    以30为旋转点，将60的左子树给30的右子树，30变成60的左子树

    由于高度和节点多了会导致的情况变的很复杂，有了以上的先例，

    使用具象图模板来表示可能出现的情况，用以下的具象图来表示，用长方形条来表示子树，

    左单旋模板：

    当子树的高度为h时，在b/c子树插入新增节点时，由于右子树比较高，需要左单旋，将b给30的右子树，30变成60的左子树。

    【因为b子树中的节点的值一定在30~60之间，所以能够满足二叉搜索树的规则，旋转后60的左右子树的高度相同，达到了平衡树的要求】

    因为只有30和60子树的高度变了，并且两者的左右子树高度相同，所以平衡因子也应该更新为0

    代码实现如下：

    1. //右边高左单旋
    2. 	void RotateL(Node* parent)
    3. 	{
    4. 		Node* subR = parent->_right;
    5. 		Node* subRL = subR->_left;
    6.  
    7. 		//将根的右子树的左子树赋值给根的右子树
    8. 		parent->_right = subRL;
    9. 		//subRL为空不能访问
    10. 		if(subRL)
    11. 			subRL->_parent = parent;
    12.  
    13. 		//将根节点变成根的右子树的左子树
    14. 		subR->_left = parent;
    15.  
    16. 		//更新根的右子树的父节点
    17. 		subR->_parent = parent->_parent;
    18. 		//如果parent是根节点需要更新根节点
    19. 		if (parent == _root)
    20. 		{
    21. 			_root = subR;
    22. 			subR->_parent = nullptr;
    23. 		}
    24. 		//如果parent上面还有祖先节点，需要更新祖先节点的左节点/右节点
    25. 		else
    26. 		{
    27. 			if (parent->_parent->_left == parent)
    28. 				parent->_parent->_left = subR;
    29. 			else
    30. 				parent->_parent->_right = subR;
    31. 		}
    32.  
    33. 		//更新根的父节点
    34. 		parent->_parent = subR;
    35.  
    36. 		//更新旋转后两个节点的平衡因子
    37. 		subR->_bf = parent->_bf = 0;
    38. 	}

    需要注意的是由于是三叉链实现，所以要更新父节点指针，注意subRL可能为空树，以及parent可能是根节点，也可能是一颗子树，注意更新根节点和parent的_parent的孩子节点指针，parent的_parent最后更新是因为更新其他节点的父节点还需要使用

    2. 新节点插入较高左子树的左侧——右单旋

    当插入到树中的数据如果为一个降序的数组，二叉搜索树会退化成一个只有左子树的单支树，效率大幅度下降，此时就会需要使用到右单旋对二叉搜索树进行平衡调整。

    方式和左单旋类似，

    右单旋模板：

    当子树高度为h时，在a/b子树插入新增节点时，由于左子树比较高，需要右单旋，将b给60的左子树，60变成30的右子树。

    【因为b子树中节点的值一定是在30到60之间的，改变后仍然满足二叉搜索树的规则，旋转后30的左右子树高度相同，满足平衡树的要求】

    因为只有30和60子树的高度变了，并且两者的左右子树高度相同，所以平衡因子也应该更新为0

    代码实现如下：

    1. //左边高右单旋
    2. 	void RotateR(Node* parent)
    3. 	{
    4. 		Node* subL = parent->_left;
    5. 		Node* subLR = subL->_right;
    6.  
    7. 		//根节点的左指针指向左子树的右子树
    8. 		parent->_left = subLR;
    9. 		//如果根节点的左子树的右子树不为空则更新_parent
    10. 		if (subLR)
    11. 			subLR->_parent = parent;
    12.  
    13. 		//根节点的左子树的右指针指向parent
    14. 		subL->_right = parent;
    15. 		//更新subL的_parent
    16. 		subL->_parent = parent->_parent;
    17.  
    18. 		//处理parent是根节点和不是根节点的情况
    19. 		//如果parent是根节点，则赋值给_root
    20. 		if (parent == _root)
    21. 		{
    22. 			_root = subL;
    23. 			subL->_parent = nullptr;
    24. 		}
    25. 		//否则链接上祖先节点
    26. 		else
    27. 		{
    28. 			//确定是祖先节点的左还是右，并链接上
    29. 			if (parent->_parent->_left == parent)
    30. 				parent->_parent->_left = subL;
    31. 			else
    32. 				parent->_parent->_right = subL;
    33. 		}
    34.  
    35. 		//更新parent的_parent
    36. 		parent->_parent = subL;
    37.  
    38. 		//更新平衡因子
    39. 		subL->_bf = parent->_bf = 0;
    40. 	}

    需要注意的是由于是三叉链实现，所以要更新父节点指针，注意subLR可能为空树，以及parent可能是根节点，也可能是一颗子树，注意更新根节点和parent的_parent的孩子节点指针，parent的_parent最后更新是因为更新其他节点的父节点还需要使用

    3. 新节点插入较高左子树的右侧——左右双旋

    左右双旋是针对当从随机数里读取数据时仍然要满足二叉平衡搜索树的规则，即在乱序的情况下能够保持是二叉平衡搜索树。

    双旋的情况比较特殊，左右双旋处理当一开始左子树的右子树较高的情况，就会需要先左单旋，然后再右单旋，由于双旋也是由单旋衍生出的，所以和单旋一样，当树中的结点变多时不好去讨论情况，所以也是采用具象图的方式进行解释

    左右双旋模板：

    当新增节点插入在b时，导致左子树的右侧较高，进行左单旋，以30为旋转点，将b给30的右子树，30变成60的左子树，就会变成单纯的左子树左侧较高，再进行右单旋，以90为旋转点，将c给90的左子树，90变成60的右子树。

    此时，第四幅图的60左右子树高度是相等的，即60的左右子树是平衡的，60的平衡因子是0，30的左右子树高度相等，即30的左右子树是平衡的，30的平衡因子是0，90的左子树比右子树矮一层，即90的左右子树是平衡的，但是90的平衡因子是1

    当新增节点插入在c时，导致左子树的右侧较高，进行左单旋，以30为旋转点，将b给30的右子树，30变成60的左子树，就会变成单纯的左子树左侧较高，再进行右单旋，以90为旋转点，将c给90的左子树，90变成60的右子树。

    此时，第四幅图的60左右子树高度是相等的，即60的左右子树是平衡的，60的平衡因子是0，90的左右子树高度相等，即90的左右子树是平衡的，90的平衡因子是0，30的右子树比左子树矮一层，即30的左右子树是平衡的，但是30的平衡因子是-1

    当60为新增节点插入在30的右子树时，导致左子树的右侧较高，进行左单旋，以30为旋转点，将60的左子树（nullptr）给30的右子树，30变成60的左子树，就会变成单纯的左子树左侧较高，再进行右单旋，以90为旋转点，将60的右子树（nullptr）给90的左子树，90变成60的右子树。

    此时，第三幅图的60左右子树高度是相等的，即60的左右子树是平衡的，60的平衡因子是0，30的左右子树高度相等，即30的左右子树是平衡的，30的平衡因子是0，90的左右子树高度相等，即90的左右子树是平衡的，90的平衡因子是0

    左右双旋也就只有上面三种情况，因为无论是从a子树（右单旋）还是d子树（平衡）亦或者是在30的左子树（右单旋）插入引发的都不是双旋。

    由此通过上述讨论，可以发现虽然30，60，90的高度都变了，需要更新平衡因子，但是也就上面三种更新情况，即当subLR（60节点）分别为-1，0，1的情况，对应上面的在60的左侧插入新增节点，60为新增节点，在60的右侧插入新增节点，分三种情况讨论更新平衡因子即可。

    代码如下：

    1. //先右边高，左单旋后左边高，右单旋
    2. 	void RotateLR(Node* parent)
    3. 	{
    4. 		//记录下根节点的左子树和根节点的左子树的右子树
    5. 		Node* subL = parent->_left;
    6. 		Node* subLR = subL->_right;
    7. 		//记录下根节点的左子树的右子树的平衡因子，后续将三个平衡因子进行更改需要使用
    8. 		int bf = subLR->_bf;
    9.  
    10. 		//先进行左单旋再进行右单旋
    11. 		RotateL(parent);
    12. 		RotateR(parent);
    13.  
    14. 		//更新parent，subL，subLR的平衡因子
    15. 		//当在subLR的左子树插入新节点导致左比右高，进而导致平衡因子变成-1，在进行左右双旋后平衡因子的更新
    16. 		if (bf == -1)
    17. 		{
    18. 			parent->_bf = 1;
    19. 			subLR->_bf = 0;
    20. 			subL->_bf = 0;
    21. 		}
    22. 		//当在subLR的右子树插入新节点导致右比左高，进而导致平衡因子变成1，在进行左右双旋后平衡因子的更新
    23. 		else if (bf == 1)
    24. 		{
    25. 			parent->_bf = 0;
    26. 			subLR->_bf = 0;
    27. 			subL->_bf = -1;
    28. 		}
    29. 		//当在subLR这颗子树就是新插入的节点，平衡因子是0，在进行左右双旋后平衡因子的更新
    30. 		else if(bf == 0)
    31. 		{
    32. 			parent->_bf = 0; 
    33. 			subLR->_bf = 0;
    34. 			subL->_bf = 0;
    35. 		}
    36. 		//走到这说明旋转前就有问题
    37. 		else
    38. 		{
    39. 			//subLR的_bf旋转前就已经出现问题
    40. 			assert(false);
    41. 		}
    42. 	}

    因为我们根据subLR这个节点来更新subLR，subL，parent的平衡因子，而在进行左单旋和右单旋，我们会将subL和subLR的平衡因子更新为0，所以要先存一份。经历完左右双旋后根据存下来的这一份平衡因子来判断我们应该怎么更新三者的平衡因子。

    4. 新节点插入较高右子树的左侧——右左双旋

    右左双旋是针对当从随机数里读取数据时仍然要满足二叉平衡搜索树的规则，即在乱序的情况下能够保持是二叉平衡搜索树。

    双旋的情况比较特殊，右左双旋处理当一开始右子树的左子树较高的情况，就会需要先右单旋，然后再左单旋，由于双旋也是由单旋衍生出的，所以和单旋一样，当树中的结点变多时不好去讨论情况，右左双旋和左右双旋类似，所以也是采用具象图的方式进行解释

    当新增节点插入在c时，导致右子树的左侧较高，进行右单旋，以90为旋转点，将c给90的左子树，90变成60的右子树，就会变成单纯的右子树右侧较高，再进行左单旋，以30为旋转点，将b给30的右子树，30变成60的左子树。

    此时，第四幅图的60左右子树高度是相等的，即60的左右子树是平衡的，60的平衡因子是0，30的左子树比右子树高度一层，即30的左右子树是平衡的，但是30的平衡因子是-1，90的左右子树高度相等，即90的左右子树是平衡的，90的平衡因子是0

    当新增节点插入在b时，导致右子树的左侧较高，进行右单旋，以90为旋转点，将c给90的左子树，90变成60的右子树，就会变成单纯的右子树右侧较高，再进行左单旋，以30为旋转点，将b给30的右子树，30变成60的左子树。

    此时，第四幅图的60左右子树高度是相等的，即60的左右子树是平衡的，60的平衡因子是0，30的左右子树高度相等，即30的左右子树是平衡的，30的平衡因子是0，90的右子树高度比左子树高一层，即90的左右子树是平衡的，但是90的平衡因子是1

    当60为新增节点插入在30的左子树时，导致右子树的左侧较高，进行右单旋，以30为旋转点，将60的右子树（nullptr）给30的左子树，30变成60的右子树，就会变成单纯的右子树右侧较高，再进行左单旋，以90为旋转点，将60的左子树（nullptr）给90的右子树，90变成60左子树。

    此时，第三幅图的60左右子树高度是相等的，即60的左右子树是平衡的，60的平衡因子是0，30的左右子树高度相等，即30的左右子树是平衡的，30的平衡因子是0，90的左右子树高度相等，即90的左右子树是平衡的，90的平衡因子是0

    右左双旋也就只有上面三种情况，因为无论是从a子树（平衡）还是d子树（左单旋）亦或者是在30的右子树（左单旋）插入引发的都不是双旋。

    由此通过上述讨论，可以发现虽然30，60，90的高度都变了，需要更新平衡因子，但是也就上面三种更新情况，即当subRL（60节点）分别为-1，0，1的情况，对应上面的在60的左侧插入新增节点，60为新增节点，在60的右侧插入新增节点，分三种情况讨论更新平衡因子即可。

    代码如下所示：

    1. //先左边高，左单旋后右边高，左单旋
    2. 	void RotateRL(Node* parent)
    3. 	{
    4. 		//记录下根节点的右子树和根节点的右子树的左子树
    5. 		Node* subR = parent->_right;
    6. 		Node* subRL = subR->_left;
    7. 		//记录下根节点的右子树的左子树的平衡因子，后续将三个平衡因子进行更改需要使用
    8. 		int bf = subRL->_bf;
    9.  
    10. 		//进行右左双旋
    11. 		RotateR(parent);
    12. 		RotateL(parent);
    13.  
    14. 		//更新parent，subR和subRL的平衡因子
    15. 		//当在subRL的右子树插入新节点导致右比左高，进而导致平衡因子变成1，在进行左右双旋后平衡因子的更新
    16. 		if (bf == 1)
    17. 		{
    18. 			parent->_bf = -1;
    19. 			subR->_bf = 0;
    20. 			subRL->_bf = 0;
    21. 		}
    22. 		//当在subRL的左子树插入新节点导致左比右高，进而导致平衡因子变成-1，在进行左右双旋后平衡因子的更新
    23. 		else if (bf == -1)
    24. 		{
    25. 			parent->_bf = 0;
    26. 			subR->_bf = 1;
    27. 			subRL->_bf = 0;
    28. 		}
    29. 		//当在subRL这颗子树就是新插入的节点，平衡因子是0，在进行左右双旋后平衡因子的更新
    30. 		else if (bf == 0)
    31. 		{
    32. 			parent->_bf = 0;
    33. 			subR->_bf = 0;
    34. 			subRL->_bf = 0;
    35. 		}
    36. 		else
    37. 		{
    38. 			assert(false);
    39. 		}
    40. 	}

    因为我们根据subRL这个节点来更新subRL，subR，parent的平衡因子，而在进行右单旋和左单旋，我们会将subL和subLR的平衡因子更新为0，所以要先存一份。经历完右左双旋后根据存下来的这一份平衡因子来判断我们应该怎么更新三者的平衡因子。

    综上所述：

    假如以parent为根的子树不平衡，即parent的平衡因子为2或者-2，分以下情况考虑：

    1. parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR

    • 当subR的平衡因子为1时，执行左单旋
    • 当subR的平衡因子为-1时，执行右左双旋

    2. parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL

    • 当subL的平衡因子为-1是，执行右单旋
    • 当subL的平衡因子为1时，执行左右双旋

    旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。

    五. AVL树的验证

    AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

    1. 验证其为二叉搜索树

    • 如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

    2. 验证其为平衡树

    • 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
    • 节点的平衡因子是否计算正确

    使用以下代码进行测试：

    1. public:
    2.  
    3.     //中序遍历
    4. 	void inoder()
    5. 	{
    6. 		_inoder(_root);
    7. 	}
    8. 	
    9. 	//返回二叉树的高度
    10. 	int Height()
    11. 	{
    12. 		return _height(_root);
    13. 	}
    14.  
    15. 	//判断是否是AVL树
    16. 	bool IsBalanceTree()
    17. 	{
    18. 		return _IsBalanceTree(_root);
    19. 	}
    20.  
    21. 	//层序遍历
    22. 	vectorint>> levelOrder() 
    23. 	{
    24. 		vectorint>> vv;
    25. 		if (_root == nullptr)
    26. 			return vv;
    27.  
    28. 		queue q;
    29. 		int levelSize = 1;
    30. 		q.push(_root);
    31.  
    32. 		while (!q.empty())
    33. 		{
    34. 			// levelSize控制一层一层出
    35. 			vector<int> levelV;
    36. 			while (levelSize--)
    37. 			{
    38. 				Node* front = q.front();
    39. 				q.pop();
    40. 				levelV.push_back(front->_kv.first);
    41. 				if (front->_left)
    42. 					q.push(front->_left);
    43.  
    44. 				if (front->_right)
    45. 					q.push(front->_right);
    46. 			}
    47. 			vv.push_back(levelV);
    48. 			for (auto e : levelV)
    49. 			{
    50. 				cout << e << " ";
    51. 			}
    52. 			cout << endl;
    53.  
    54. 			// 上一层出完，下一层就都进队列
    55. 			levelSize = q.size();
    56. 		}
    57.  
    58. 		return vv;
    59. 	}
    60.  
    61. private:
    62.     //中序遍历
    63. 	void _inoder(Node* root)
    64. 	{
    65. 		if (root == nullptr)
    66. 			return;
    67.  
    68. 		_inoder(root->_left);
    69. 		cout << root->_kv.first << " ";
    70. 		_inoder(root->_right);
    71. 	}
    72.  
    73. 	//求二叉平衡树的高度
    74. 	int _height(Node* root)
    75. 	{
    76. 		if (root == nullptr)
    77. 			return 0;
    78.  
    79. 		int left = _height(root->_left);
    80. 		int right = _height(root->_right);
    81.  
    82. 		return left > right ? left + 1 : right + 1;
    83. 	}
    84.  
    85. 	//判断是否是AVL树
    86. 	bool _IsBalanceTree(Node* root)
    87. 	{
    88. 		//空树也是AVL树
    89. 		if (nullptr == root)
    90. 			return true;
    91.  
    92. 		//计算root节点的平衡因子：即root左右子树的高度差
    93. 		int leftHeight = _height(root->_left);
    94. 		int rightHeight = _height(root->_right);
    95. 		int diff = rightHeight - leftHeight;
    96.  
    97. 		//如果计算出的平衡因子与root的平衡因子不相等，或者
    98. 		//root平衡因子的绝对值超过1，则一定不是AVL树
    99. 		if (abs(diff) >= 2)
    100. 		{
    101. 			cout << root->_kv.first << "节点平衡因子异常" << endl;
    102. 			return false;
    103. 		}
    104.  
    105. 		if (diff != root->_bf)
    106. 		{
    107. 			cout << root->_kv.first << "节点平衡因子不符合实际" << endl;
    108. 			return false;
    109. 		}
    110.  
    111. 		//root的左和右如果都是AVL树，则该树一定是AVL树
    112. 		return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
    113. 	}

    并输入以下数据进行测试：

    常规用例：

    16, 3, 7, 11, 9, 26, 18, 14, 15

    特殊用例：

    4, 2, 6, 1, 3, 5, 15, 7, 16, 14

    五. AVL树的性能

    VL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这 样可以保证查询时高效的时间复杂度，即O(logN)。但是如果要对AVL树做一些结构修改的操 作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时， 有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

    六. AVL树的删除（了解向）

    因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的是删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

    删除了节点，所以往上更新的平衡都应该-1，直至遇到不平衡的节点进行旋转或者更新到节点的平衡因子为-1/1时停止，否则将一路更新到根节点，左子树改变-(-1)就需要加1，而右子树改变就应该-1。

    注：更新到-1或者1的时候停止是因为，能更新到-1或者1的节点，以该节点为根节点的子树本来就是平衡，即根节点的平衡因子是0，当删除一个其中一个节点后仍然满足平衡树（前提是删除的这个节点满足二叉搜索树的要求）的要求

    有如上AVL树：

    当删除的节点为9时

    此时应该8节点的右指针指向9的孩子节点，再链接9后面的子树，并且需要从8节点往上更新各个节点的平衡因子，因为删除了节点且为8的右子树，所以往上更新都应该-1，一路更新到根节点

    当删除的节点为6时

    此时就应该反过来，由于是左节点，所以就应该+1，再链接6节点后的子树，由于以7为根节点的子树不再平衡，所以应该进行旋转，由于是左高，所以应该进行右单旋

    当删除的节点为2时

     删除了1的右节点，由于1的平衡因子本来是0，所以减一后是-1，说明子树平衡，不需要向上更新平衡因子，只需要链接2节点后的子树即可

    以上只是列了几种的情况，真正讨论起来，情况复杂很多，并且细节也很多，这里不过多赘述。

    具体实现参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

    七. AVL树的完整实现代码

    以下是AVL树完整代码的展示：

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. using namespace std;
    8.  
    9.  
    10. /*
    11. 	实现AVL树，并且是kv结构的三叉链
    12. */
    13.  
    14. template<class K, class V>
    15. struct AVLTreeNode
    16. {
    17. 	pair _kv;
    18. 	AVLTreeNode* _left;
    19. 	AVLTreeNode* _right;
    20. 	AVLTreeNode* _parent;
    21.  
    22. 	int _bf;//平衡因子
    23. 	//AVL树并没有规定必须要选择设计平衡因子，只是一个实现的选择，方便控制
    24.  
    25. 	//构造函数
    26. 	AVLTreeNode(const pair& kv)
    27. 		:_kv(kv)
    28. 		, _left(nullptr)
    29. 		, _right(nullptr)
    30. 		, _parent(nullptr)
    31. 		, _bf(0)
    32. 	{}
    33.  
    34. };
    35.  
    36. template<class K, class V>
    37. class AVLTree
    38. {
    39. 	typedef AVLTreeNode Node;
    40. public:
    41.  
    42. 	bool insert(const pair& kv)
    43. 	{
    44. 		if (_root == nullptr)
    45. 		{
    46. 			_root = new Node(kv);
    47. 			_root->_bf = 0;
    48. 			return true;
    49. 		}
    50.  
    51. 		//遍历查找插入节点
    52. 		Node* parent = nullptr;
    53. 		Node* cur = _root;
    54. 		while (cur != nullptr)
    55. 		{
    56. 			parent = cur;
    57. 			if (cur->_kv.first < kv.first)
    58. 				cur = cur->_right;
    59. 			else if (cur->_kv.first > kv.first)
    60. 				cur = cur->_left;
    61. 			else
    62. 				return false;
    63. 		}
    64.  
    65. 		//将节点插入树中
    66. 		cur = new Node(kv);
    67. 		if (parent->_kv.first > kv.first)
    68. 			parent->_left = cur;
    69. 		else
    70. 			parent->_right = cur;
    71. 		//将新插入节点的_parent被parent赋值
    72. 		cur->_parent = parent;
    73.  
    74. 		//平衡二叉搜树
    75. 		while (parent != nullptr)
    76. 		{
    77. 			//更新父节点的平衡因子
    78. 			if (parent->_left == cur)
    79. 				parent->_bf--;
    80. 			else
    81. 				parent->_bf++;
    82.  
    83. 			//判断是否需要继续更新
    84. 			//1或-1说明高度变了，需要继续更新祖先节点的平衡因子
    85. 			if (parent->_bf == 1 || parent->_bf == -1)
    86. 			{
    87. 				cur = cur->_parent;
    88. 				parent = parent->_parent;
    89. 			}
    90. 			//0说明平衡了，不需要继续往上更新
    91. 			else if (parent->_bf == 0)
    92. 			{
    93. 				break;
    94. 			}
    95. 			//2和-2，不符合规则，需要旋转
    96. 			else if (parent->_bf == 2 || parent->_bf == -2)
    97. 			{
    98. 				//右边高，左单旋
    99. 				if (parent->_bf == 2 && cur->_bf == 1)
    100. 					RotateL(parent);
    101. 				//左边高右单旋
    102. 				else if (parent->_bf == -2 && cur->_bf == -1)
    103. 					RotateR(parent);
    104. 				//先
    105. 				else if (parent->_bf == -2 && cur->_bf == 1)
    106. 					RotateLR(parent);
    107. 				else if (parent->_bf == 2 && cur->_bf == -1)
    108. 					RotateRL(parent);
    109.  
    110. 				// 旋转完成后，整棵树已经是平衡搜索二叉树，跳出循环
    111. 				break;
    112. 			}
    113. 			else
    114. 			{
    115. 				//走到这说明这颗二叉树本来就有子树不满足平衡二叉树
    116. 				assert(false);
    117. 			}
    118.  
    119. 		}
    120.  
    121. 	}
    122.  
    123. 	//以下接口用来验证是否是二叉平衡搜索树、
    124. 	//中序遍历
    125. 	void inoder()
    126. 	{
    127. 		_inoder(_root);
    128. 	}
    129. 	
    130. 	//返回二叉树的高度
    131. 	int Height()
    132. 	{
    133. 		return _height(_root);
    134. 	}
    135.  
    136. 	//判断是否是AVL树
    137. 	bool IsBalanceTree()
    138. 	{
    139. 		return _IsBalanceTree(_root);
    140. 	}
    141.  
    142. 	//层序遍历
    143. 	vectorint>> levelOrder() 
    144. 	{
    145. 		vectorint>> vv;
    146. 		if (_root == nullptr)
    147. 			return vv;
    148.  
    149. 		queue q;
    150. 		int levelSize = 1;
    151. 		q.push(_root);
    152.  
    153. 		while (!q.empty())
    154. 		{
    155. 			// levelSize控制一层一层出
    156. 			vector<int> levelV;
    157. 			while (levelSize--)
    158. 			{
    159. 				Node* front = q.front();
    160. 				q.pop();
    161. 				levelV.push_back(front->_kv.first);
    162. 				if (front->_left)
    163. 					q.push(front->_left);
    164.  
    165. 				if (front->_right)
    166. 					q.push(front->_right);
    167. 			}
    168. 			vv.push_back(levelV);
    169. 			for (auto e : levelV)
    170. 			{
    171. 				cout << e << " ";
    172. 			}
    173. 			cout << endl;
    174.  
    175. 			// 上一层出完，下一层就都进队列
    176. 			levelSize = q.size();
    177. 		}
    178.  
    179. 		return vv;
    180. 	}
    181.  
    182.  
    183.  
    184. private:
    185.  
    186. 	//右边高左单旋
    187. 	void RotateL(Node* parent)
    188. 	{
    189. 		Node* subR = parent->_right;
    190. 		Node* subRL = subR->_left;
    191.  
    192. 		//将根的右子树的左子树赋值给根的右子树
    193. 		parent->_right = subRL;
    194. 		//subRL为空不能访问
    195. 		if(subRL)
    196. 			subRL->_parent = parent;
    197.  
    198. 		//将根节点变成根的右子树的左子树
    199. 		subR->_left = parent;
    200.  
    201. 		//更新根的右子树的父节点
    202. 		subR->_parent = parent->_parent;
    203. 		//如果parent是根节点需要更新根节点
    204. 		if (parent == _root)
    205. 		{
    206. 			_root = subR;
    207. 			subR->_parent = nullptr;
    208. 		}
    209. 		//如果parent上面还有祖先节点，需要更新祖先节点的左节点/右节点
    210. 		else
    211. 		{
    212. 			if (parent->_parent->_left == parent)
    213. 				parent->_parent->_left = subR;
    214. 			else
    215. 				parent->_parent->_right = subR;
    216. 		}
    217.  
    218. 		//更新根的父节点
    219. 		parent->_parent = subR;
    220.  
    221. 		//更新旋转后两个节点的平衡因子
    222. 		subR->_bf = parent->_bf = 0;
    223. 	}
    224.  
    225. 	//左边高右单旋
    226. 	void RotateR(Node* parent)
    227. 	{
    228. 		Node* subL = parent->_left;
    229. 		Node* subLR = subL->_right;
    230.  
    231. 		//根节点的左指针指向左子树的右子树
    232. 		parent->_left = subLR;
    233. 		//如果根节点的左子树的右子树不为空则更新_parent
    234. 		if (subLR)
    235. 			subLR->_parent = parent;
    236.  
    237. 		//根节点的左子树的右指针指向parent
    238. 		subL->_right = parent;
    239. 		//更新subL的_parent
    240. 		subL->_parent = parent->_parent;
    241.  
    242. 		//处理parent是根节点和不是根节点的情况
    243. 		//如果parent是根节点，则赋值给_root
    244. 		if (parent == _root)
    245. 		{
    246. 			_root = subL;
    247. 			subL->_parent = nullptr;
    248. 		}
    249. 		//否则链接上祖先节点
    250. 		else
    251. 		{
    252. 			//确定是祖先节点的左还是右，并链接上
    253. 			if (parent->_parent->_left == parent)
    254. 				parent->_parent->_left = subL;
    255. 			else
    256. 				parent->_parent->_right = subL;
    257. 		}
    258.  
    259. 		//更新parent的_parent
    260. 		parent->_parent = subL;
    261.  
    262. 		//更新平衡因子
    263. 		subL->_bf = parent->_bf = 0;
    264. 	}
    265.  
    266. 	//先右边高，左单旋后左边高，右单旋
    267. 	void RotateLR(Node* parent)
    268. 	{
    269. 		//记录下根节点的左子树和根节点的左子树的右子树
    270. 		Node* subL = parent->_left;
    271. 		Node* subLR = subL->_right;
    272. 		//记录下根节点的左子树的右子树的平衡因子，后续将三个平衡因子进行更改需要使用
    273. 		int bf = subLR->_bf;
    274.  
    275. 		//先进行左单旋再进行右单旋
    276. 		RotateL(parent);
    277. 		RotateR(parent);
    278.  
    279. 		//更新parent，subL，subLR的平衡因子
    280. 		//当在subLR的左子树插入新节点导致左比右高，进而导致平衡因子变成-1，在进行左右双旋后平衡因子的更新
    281. 		if (bf == -1)
    282. 		{
    283. 			parent->_bf = 1;
    284. 			subLR->_bf = 0;
    285. 			subL->_bf = 0;
    286. 		}
    287. 		//当在subLR的右子树插入新节点导致右比左高，进而导致平衡因子变成1，在进行左右双旋后平衡因子的更新
    288. 		else if (bf == 1)
    289. 		{
    290. 			parent->_bf = 0;
    291. 			subLR->_bf = 0;
    292. 			subL->_bf = -1;
    293. 		}
    294. 		//当在subLR这颗子树就是新插入的节点，平衡因子是0，在进行左右双旋后平衡因子的更新
    295. 		else if(bf == 0)
    296. 		{
    297. 			parent->_bf = 0; 
    298. 			subLR->_bf = 0;
    299. 			subL->_bf = 0;
    300. 		}
    301. 		//走到这说明旋转前就有问题
    302. 		else
    303. 		{
    304. 			//subLR的_bf旋转前就已经出现问题
    305. 			assert(false);
    306. 		}
    307. 	}
    308.  
    309. 	//先左边高，左单旋后右边高，左单旋
    310. 	void RotateRL(Node* parent)
    311. 	{
    312. 		//记录下根节点的右子树和根节点的右子树的左子树
    313. 		Node* subR = parent->_right;
    314. 		Node* subRL = subR->_left;
    315. 		//记录下根节点的右子树的左子树的平衡因子，后续将三个平衡因子进行更改需要使用
    316. 		int bf = subRL->_bf;
    317.  
    318. 		//进行右左双旋
    319. 		RotateR(parent);
    320. 		RotateL(parent);
    321.  
    322. 		//更新parent，subR和subRL的平衡因子
    323. 		//当在subRL的右子树插入新节点导致右比左高，进而导致平衡因子变成1，在进行左右双旋后平衡因子的更新
    324. 		if (bf == 1)
    325. 		{
    326. 			parent->_bf = -1;
    327. 			subR->_bf = 0;
    328. 			subRL->_bf = 0;
    329. 		}
    330. 		//当在subRL的左子树插入新节点导致左比右高，进而导致平衡因子变成-1，在进行左右双旋后平衡因子的更新
    331. 		else if (bf == -1)
    332. 		{
    333. 			parent->_bf = 0;
    334. 			subR->_bf = 1;
    335. 			subRL->_bf = 0;
    336. 		}
    337. 		//当在subRL这颗子树就是新插入的节点，平衡因子是0，在进行左右双旋后平衡因子的更新
    338. 		else if (bf == 0)
    339. 		{
    340. 			parent->_bf = 0;
    341. 			subR->_bf = 0;
    342. 			subRL->_bf = 0;
    343. 		}
    344. 		else
    345. 		{
    346. 			assert(false);
    347. 		}
    348. 	}
    349.  
    350. 	//中序遍历
    351. 	void _inoder(Node* root)
    352. 	{
    353. 		if (root == nullptr)
    354. 			return;
    355.  
    356. 		_inoder(root->_left);
    357. 		cout << root->_kv.first << " ";
    358. 		_inoder(root->_right);
    359. 	}
    360.  
    361. 	//求二叉平衡树的高度
    362. 	int _height(Node* root)
    363. 	{
    364. 		if (root == nullptr)
    365. 			return 0;
    366.  
    367. 		int left = _height(root->_left);
    368. 		int right = _height(root->_right);
    369.  
    370. 		return left > right ? left + 1 : right + 1;
    371. 	}
    372.  
    373. 	//判断是否是AVL树
    374. 	bool _IsBalanceTree(Node* root)
    375. 	{
    376. 		//空树也是AVL树
    377. 		if (nullptr == root)
    378. 			return true;
    379.  
    380. 		//计算root节点的平衡因子：即root左右子树的高度差
    381. 		int leftHeight = _height(root->_left);
    382. 		int rightHeight = _height(root->_right);
    383. 		int diff = rightHeight - leftHeight;
    384.  
    385. 		//如果计算出的平衡因子与root的平衡因子不相等，或者
    386. 		//root平衡因子的绝对值超过1，则一定不是AVL树
    387. 		if (abs(diff) >= 2)
    388. 		{
    389. 			cout << root->_kv.first << "节点平衡因子异常" << endl;
    390. 			return false;
    391. 		}
    392.  
    393. 		if (diff != root->_bf)
    394. 		{
    395. 			cout << root->_kv.first << "节点平衡因子不符合实际" << endl;
    396. 			return false;
    397. 		}
    398.  
    399. 		//root的左和右如果都是AVL树，则该树一定是AVL树
    400. 		return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
    401. 	}
    402.  
    403. 	Node* _root = nullptr;
    404. };
  • 相关阅读:
    SpringBoot与mockito那点事
    Java的IO流-序列化流
    【web-攻击访问控制】（5.1.1）常见漏洞：完全不受保护的功能、基于标识符的功能
    为什么 Spring的构造器注入不需要 @Autowired 注解
    基于隐私保护的联邦推荐算法综述
    线段树知识整理
    深入体会线程状态的切换
    冯诺伊曼体系结构和操作系统
    JavaScript——JSON
    java计算机毕业设计基于springboo+vue的个人家庭理财记账管理系统
  • 原文地址：https://blog.csdn.net/Britney_dark/article/details/127651961