【AVL树】—— 我与C++的不解之缘（二十三）

什么是AVL树？

• AVL树发明者是G. M. Adelson-Velsky和E. M. Landis两个前苏联科学家，他们在1962年论文《An algorithm for the organization of information》中发表了AVL树。
• AVL树是最先发明的自平衡二叉搜索树，说白了就是能够自己控制平衡结构的一个二叉搜索树；AVL可以是一个空树，或者其左右树都是AVL树，且左右子树的高度差的绝对值不超过1。
• AVL树，左右子树的高度差不超过一，而不是0？（如果一棵树的节点个数是2、4等的情况下，高度差最好情况就是1，到不到0。
• 本篇在实现AVL树时，引入了一个新的概念(平衡因子)；每个节点都存在平衡因子，平衡因子等于右子树的高度减去左子树的高度，这样平衡因子的取值就是(0、1、-1)；（平衡因子也不是必须的，这里引入平衡因子这一概念，方便观察和控制整个AVL树的平衡。

​ 简单来说，AVL树就是一个特殊的搜索二叉树，特殊就特殊在它可以控制平衡，保持左右子树的高度差不超过1。

那又是如何实现的呢？

AVL树的实现

1. AVL树的结构

先来看一下AVL树的结构，首先就是AVL树的节点

1. template<class k,class="" v="">
2. struct TreeNode {
3. int _bf;
4. pair<k, v=""> _kv;
5. TreeNode<k, v="">* _left;
6. TreeNode<k, v="">* _right;
7. TreeNode<k, v="">* _parent;
9. TreeNode(const pair<k, v=""> kv)
10. :_kv(kv)
11. , _bf(0)
12. , _left(nullptr)
13. , _right(nullptr)
14. , _parent(nullptr)
15. {}
16. };

复制代码

这里并没有直接存储数据K，和V，而是像map那样将其封装成一个pair类型。

再来看一下AVL树都要实现哪些方法

1. template<class k,class="" v="">
2. class AVLTree
3. {
4. typedef TreeNode<k, v=""> Node;
5. public:
6. //插入
7. bool insert(const pair<k, v=""> kv) {}
8. //查找
9. bool find(const K& kev) {}
11. //中序遍历
12. void order() {}
13. private:
14. //右单旋
15. void RevoleR(Node* parent) {}
16. //左单旋
17. void RevoleL(Node* parent) {}
18. //右左双选
19. void RevoleRL(Node* parent) {}
20. //左右双选
21. void RevoleLR(Node* parent) {}
22. //中序遍历
23. void order(Node* root) {}
24. Node* _root;
25. };

复制代码

这里实现了几个私有的成员方法，因为这些方法不希望在类外被直接访问。（其中order()是为了实现中序遍历，因为在类外无法访问到该树的根节点。）

2. AVL树的插入

插入过程

对于插入数据的整个过程，其实就是在搜索二叉树的基础上，增加了更新平衡因子和在更新平衡因子的过程中需要旋转的情况就行旋转。

• 按搜索二叉树的规则进行插入数据
• 新增节点以后，就可能会影响到部分祖先节点的平衡因子，所以从新增节点 -> 根节点这整个路径上节点的平衡因子（在更新的过程中，可能会遇到继续更新，更新结束以及需要旋转的情况。）
• 更新平衡因子过程中没有出现问题，插入就结束了。
• 在平衡的过程中，出现了不平衡的情况，就要堆不平衡子树进行旋转，选择后调平衡的同时，也降低了子树的高度，就不会影响上一层的平衡因子，插入也就结束了。

更新平衡因子

首先，平衡因子=右子树高度-左子树高度

• 插入节点会增加高度，所以，新增节点如果是在parent节点的右子树，则parent节点的平衡因子++；如果是在parent节点的左子树，那么parent节点的平衡因子–；
• parent所在子树的高度是否变化就决定了是否要继续往上更新平衡因子。

更新平衡因子可能遇到的情况：

• 更新之后parent节点平衡因子等于0：更新过程中parent的平衡因子变化-1->0或者1->0，这说明了插入节点之前parent子树一边高一边低，新增节点插入到了低的那一边，插入节点后以parent为根节点的子树的高度不变，就不会影响其父节点的平衡因子（就不会影响到上面节点的平衡）所以更新就结束了。
• 更新之后parent节点平衡因子等于1或-1：更新过程中parent的平衡因子变化0->-1或者0->1，这就说明了，插入节点之前，parent的左右子树高度相同了，插入节点之后parent子树的高度发生了变化，所以就会影响其父节点的平衡因子，从而影响上面节点的平衡；所以需要继续更新平衡因子。
• 更新之后parent节点平衡因子等于2或者-2：更新过程中parent的平衡因子变化1->2或者-1->-2，这说明，在插入节点之前，以parent为根节点的子树就已经一边高一边低了；然后新增节点还插入到了高的那一边，这样以parent为根节点的子树就已经不满足AVL树的结构了，此时就需要对该树就行旋转（旋转：一是将以parent为根节点的子树调整平衡，二是降低以parent为根节点的子树的高度，回复到插入以前的高度）；旋转完成后，就不需要继续更新平衡因子了。

更新之后parent节点平衡因子为0

更新之后parent节点平衡因子为1或者-1

更新之后parent节点平衡因子为2或者-2

更新平衡因子的过程实现

1. bool insert(const pair<k, v=""> kv)
2. {
3. Node* newnode = Node(kv);
4. if (_root == nullptr)
5. {
6. _root = newnode;
7. return true;
8. }
9. Node* parent = nullptr;
10. Node* pcur = _root;
11. while (pcur)
12. {
13. if (kv.first > pcur->_kv.first)
14. {
15. parent = pcur;
16. pcur = pcur->_right;
17. }
18. else if (kv.first < pcur->_kv.first)
19. {
20. parent = pcur;
21. pcur = pcur->_left;
22. }
23. else
24. {
25. return false;
26. }
27. }
28. pcur = newnode;
29. newnode->_parent = parent;
30. if (kv.first > parent->_kv.first)
31. {
32. parent->_right = pcur;
33. }
34. else if (kv.first < parent->_kv.first)
35. {
36. parent->_left = pcur;
37. }
38. else
39. {
40. return false;
41. }
42. //更新平衡因子
43. while (parent)
44. {
45. if (pcur == parent->_left)
46. {
47. --parent->_bf;
48. }
49. else
50. {
51. ++parent->_bf;
52. }
53. if (parent->_bf == 0)
54. {
55. break;
56. }
57. else if (parent->_bf == 1 || parent->_bf == -1)
58. {
59. pcur = parent;
60. parent = parent->_parent;
61. }
62. else if (parent->_bf == 2 || parent->_bf == -2)
63. {
64. //旋转
65. }
66. }
67. return true;
68. }

复制代码

3.旋转

新插入节点以及更新平衡因子如上述，那么在更新平衡因子过程中，遇到平衡因子等于2（也就是以parent为根节点的子树不平衡）需要进行旋转，那如何旋转的呢？

旋转的规则：

• 保持搜索树的原则。
• 将要旋转的树从不满足到满足平衡，其次降低树的高度。

旋转一共分为四种（左单旋、右单旋、左右双旋、右左双旋），其每一种旋转都对应一种情况；

左单旋

先来看一下这种情况：

如上图中以5为根节点的子树，其中a、b、c都是高度为h的子树（h可以等于0）；现在要在a子树中插入一个节点，在更新平衡因子的过程中，5所在节点的平衡因子1 -> 2，此时该子树就不平衡了，需要进行旋转；

通过观察上图，我们可以发现，5节点的右子树太高了，所以我们需要向左旋转来平衡高度；

如何旋转呢？

旋转步骤

• b子树变成5节点的右子树；
• 以5节点为根节点的子树变成10节点的左子树；
• 10节点就变成了这个子树新的根节点。

其中5

然后10节点变成了这部分子树新的根节点。（并不一定是整个子树新的根节点）。

代码实现：

1. //左单旋
2. void RevoleL(Node* parent)
3. {
4. //旋转节点的右孩子节点
5. Node* subr = parent->_right;
6. //旋转节点的右孩子节点的左孩子节点
7. Node* subrl = parent->_right->_left;
9. //subrl变成parent的右子树
10. parent->_right = subrl;
11. //subrl可能为空
12. if (subrl)
13. subrl->_parent = parent;
14. //parent->变成subr的左子树
15. subr->_left = parent;
17. //记录parent的父节点
18. Node* pnode = parent->_parent;
19. parent->_parent = subr;
20. //如果parent是整个avl树的根节点
21. if (pnode == nullptr)
22. {
23. _root = subr;
24. subr->_parent = nullptr;
25. }
26. else
27. {
28. //parent父节点不为空
29. subr->_parent = pnode;
30. if (pnode->_left == parent)
31. {
32. pnode->_left = subr;
33. }
34. else
35. {
36. pnode->_right = subr;
37. }
38. }
39. //调整完之后将parent节点与subr节点的平衡因子修改成0
40. parent->_bf = 0;
41. subr->_bf = 0;
42. }

复制代码

右单旋

了解了左单旋，右单旋就十分简单了：

和左单旋的情况相似，有单旋就是10节点的左子树高，需要进行右单旋；

旋转步骤

• b子树变成10节点的左子树；
• 以10节点为根节点的子树变成5节点的右子树；
• 5节点就变成这部分子树的根节点。

其中5

5节点就变成了这部分子树的根节点。

代码实现

1. //右单旋
2. void RevoleR(Node* parent)
3. {
4. //旋转节点的左孩子节点
5. Node* subl = parent->_left;
6. //旋转节点的左孩子节点的右孩子节点
7. Node* sublr = parent->_left->_right;
9. //sublr变成parent的左孩子节点
10. parent->_left = sublr;
11. //sublr可能为nullptr
12. if (sublr)
13. sublr->_parent = parent;
15. //parent变成subl的右孩子节点
16. subl->_right = parent;
18. //记录parent的父节点
19. Node* pnode = parent->_parent;
20. if (pnode == nullptr)
21. {
22. _root = subl;
23. subl->_parent = nullptr;
24. }
25. else
26. {
27. subl->_parent = pnode;
28. if (pnode->_left == parent)
29. {
30. pnode->_left = subl;
31. }
32. else
33. {
34. pnode->_right = subl;
35. }
36. }
37. //修改parent 和 subl 的平衡因子
38. parent->_bf = 0;
39. subl->_bf = 0;
40. }

复制代码

左右双旋

左单旋、右单旋都是纯粹的一边高（就是在parent的左/右孩子的左/右孩子所在子树中插入数据）；按上述说，就是在a子树中插入数据，但是如果是在b子树中插入数据呢？

如上图，我们很显然不能单纯的使用右单旋或者左单旋来解决问题了；

旋转步骤

左右双旋其实就是，先对parent的左孩子节点进行一次左单选，再对parent节点进行一次右单旋；

来看分析：

这里h是能够等于0的，我们分开来讨论：
h=0

我们先对subl节点进行一次左单旋，再对parent节点进行一次右单旋；

h!=0

对于h!=0的情况，b子树中就至少有一个节点，那我们要分为两种情况讨论；

我们将一个avl树抽象成下面这种情况：

这样我们可以看出来，可能是在e子树中插入数据，也可能是在f子树中插入数据；那这两种情况就也要分开讨论：

在e子树中插入

此时，我们还是先对subl节点左单旋，变成纯粹的一边高，再对parent节点进行右单旋；

在f子树插入节点

还是先对subl左单旋，再对parent进行右单旋；

通过观察，我们可以发现，这三种情况都是进行了一次左单旋和一次右单旋，不同的是其结果中subl和parent的平衡因子不同。

这样我们在实现时，就直接复用左单旋和右单旋就好了，然后根据其平衡因子的情况来判断最后subl和parent节点的平衡因子即可。

更新平衡因子

• sublr节点平衡因子等于0： sublr、subl和parent平衡因子都为0；
• sublr节点平衡因子等于-1：sublr和subl平衡因子等于0，parent平衡因子等于1；
• sublr节点平衡因子等于1：sublr和parent平衡因子等于0，subl平衡因子等于-1；

代码实现

代码实现过程中有一个细节就是：

在进行左右单旋时，会将平衡因子修改成0，我们就需要先记录一下sublr原本的平衡因子，来保证我们单旋结束后的平衡因子的修改。

1. //左右双选
2. void RevoleLR(Node* parent)
3. {
4. Node* subl = parent->_left;
5. Node* sublr = parent->_left->_right;
6. int bf = sublr->_bf;
7. //对subl进行左单旋
8. RevoleL(subl);
9. //对parent进行右单旋
10. RevoleR(parent);
12. //更新平衡因子
13. if (bf == 0)
14. {
15. parent->_bf = 0;
16. subl->_bf = 0;
17. sublr->_bf = 0;
18. }
19. else if (bf == 1)
20. {
21. parent->_bf = 0;
22. subl->_bf = -1;
23. sublr->_bf = 0;
24. }
25. else if (bf == -1)
26. {
27. parent->_bf = 1;
28. subl->_bf = 0;
29. sublr->_bf = 0;
30. }
31. }

复制代码

右左双旋

右左双旋和左右双旋逻辑非常像，这里就不演示了，直接看代码实现：

1. //右左双选
2. void RevoleRL(Node* parent)
3. {
4. Node* subr = parent->_right;
5. Node* subrl = parent->_right->_left;
6. int bf = subrl->_bf;
7. RevoleR(subr);
8. RevoleL(parent);
9. if (bf == 0)
10. {
11. parent->_bf = 0;
12. subr->_bf = 0;
13. subrl->_bf = 0;
14. }
15. else if (bf == 1)
16. {
17. parent->_bf = -1;
18. subr->_bf = 0;
19. subrl->_bf = 0;
20. }
21. else if (bf == -1)
22. {
23. parent->_bf = 0;
24. subr->_bf = 1;
25. subrl->_bf = 0;
26. }
27. }

复制代码

在旋转实现完成之后我们就可以完善我们insert了：

1. //插入
2. bool insert(const pair<k, v=""> kv)
3. {
4. Node* newnode = Node(kv);
5. if (_root == nullptr)
6. {
7. _root = newnode;
8. return true;
9. }
10. Node* parent = nullptr;
11. Node* pcur = _root;
12. while (pcur)
13. {
14. if (kv.first > pcur->_kv.first)
15. {
16. parent = pcur;
17. pcur = pcur->_right;
18. }
19. else if (kv.first < pcur->_kv.first)
20. {
21. parent = pcur;
22. pcur = pcur->_left;
23. }
24. else
25. {
26. return false;
27. }
28. }
29. pcur = newnode;
30. newnode->_parent = parent;
31. if (kv.first > parent->_kv.first)
32. {
33. parent->_right = pcur;
34. }
35. else if (kv.first < parent->_kv.first)
36. {
37. parent->_left = pcur;
38. }
39. else
40. {
41. return false;
42. }
43. //更新平衡因子
44. while (parent)
45. {
46. if (pcur == parent->_left)
47. {
48. --parent->_bf;
49. }
50. else
51. {
52. ++parent->_bf;
53. }
54. if (parent->_bf == 0)
55. {
56. break;
57. }
58. else if (parent->_bf == 1 || parent->_bf == -1)
59. {
60. pcur = parent;
61. parent = parent->_parent;
62. }
63. else if (parent->_bf == 2 || parent->_bf == -2)
64. {
65. //旋转
66. if (parent->_bf == 2 && parent->_left->_bf == 1)
67. {
68. //左单旋
69. RevoleL(parent);
70. }
71. else if (parent->_bf == 2 && parent->_left->_bf == -1)
72. {
73. //右左双旋
74. RevoleRL(parent);
75. }
76. else if (parent->_bf == -2 && parent->_right->_bf == -1)
77. {
78. //右单旋
79. RevoleR(parent);
80. }
81. else if (parent->_bf == -2 && parent->_left->_bf == 1)
82. {
83. //左右双旋
84. RevoleLR(parent);
85. }
86. }
87. }
89. return true;
90. }

复制代码

旋转了解完以后，就可以完善之前的插入功能了：

1. //插入
2. bool insert(const pair<k, v=""> kv)
3. {
4. Node* newnode = new Node(kv);
5. if (_root == nullptr)
6. {
7. _root = newnode;
8. return true;
9. }
10. Node* parent = nullptr;
11. Node* pcur = _root;
12. while (pcur)
13. {
14. if (kv.first > pcur->_kv.first)
15. {
16. parent = pcur;
17. pcur = pcur->_right;
18. }
19. else if (kv.first < pcur->_kv.first)
20. {
21. parent = pcur;
22. pcur = pcur->_left;
23. }
24. else
25. {
26. return false;
27. }
28. }
29. pcur = newnode;
30. newnode->_parent = parent;
31. if (kv.first > parent->_kv.first)
32. {
33. parent->_right = pcur;
34. }
35. else if (kv.first < parent->_kv.first)
36. {
37. parent->_left = pcur;
38. }
39. else
40. {
41. return false;
42. }
43. //更新平衡因子
44. while (parent)
45. {
46. if (pcur == parent->_left)
47. {
48. --parent->_bf;
49. }
50. else
51. {
52. ++parent->_bf;
53. }
54. if (parent->_bf == 0)
55. {
56. break;
57. }
58. else if (parent->_bf == 1 || parent->_bf == -1)
59. {
60. pcur = parent;
61. parent = parent->_parent;
62. }
63. else if (parent->_bf == 2 || parent->_bf == -2)
64. {
65. //旋转
66. if (parent->_bf == 2 && parent->_left->_bf == 1)
67. {
68. //左单旋
69. RevoleL(parent);
70. }
71. else if (parent->_bf == 2 && parent->_left->_bf == -1)
72. {
73. //右左双旋
74. RevoleRL(parent);
75. }
76. else if (parent->_bf == -2 && parent->_right->_bf == -1)
77. {
78. //右单旋
79. RevoleR(parent);
80. }
81. else if (parent->_bf == -2 && parent->_left->_bf == 1)
82. {
83. //左右双旋
84. RevoleLR(parent);
85. }
86. }
87. }
88. return true;
89. }

复制代码

4. AVL树的查找

AVL树的查找先对就简单多了，和搜索二叉树查找一样。

1. //查找
2. bool find(const K& kv)
3. {
4. Node* ptail = _root;
5. while (ptail)
6. {
7. if (kv.first > ptail->_kv->first)
8. {
9. ptail = ptail->_right;
10. }
11. else if (kv.first < ptail->_kv->first)
12. {
13. ptail = ptail->_left;
14. }
15. else
16. {
17. return true;
18. }
19. }
20. return false;
21. }

复制代码

对于AVL树的删除，有点过于复杂，感兴趣的可以深入探究一下；后面研究过了再来探讨这个问题。

1. }
2. else if (parent->_bf == -2 && parent->_right->_bf == -1)
3. {
4. //右单旋
5. RevoleR(parent);
6. }
7. else if (parent->_bf == -2 && parent->_left->_bf == 1)
8. {
9. //左右双旋
10. RevoleLR(parent);
11. }
12. }
13. }
14. return true;

复制代码

}

2. ## 4. `AVL`树的查找
4. `AVL`树的查找先对就简单多了，和搜索二叉树查找一样。
6. ```cpp
7. //查找
8. bool find(const K& kv)
9. {
10. Node* ptail = _root;
11. while (ptail)
12. {
13. if (kv.first > ptail->_kv->first)
14. {
15. ptail = ptail->_right;
16. }
17. else if (kv.first < ptail->_kv->first)
18. {
19. ptail = ptail->_left;
20. }
21. else
22. {
23. return true;
24. }
25. }
26. return false;
27. }

复制代码

对于AVL树的删除，有点过于复杂，感兴趣的可以深入探究一下；后面研究过了再来探讨这个问题。

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=2oul0hvapjsws