【C++】17. AVL树实现

一、AVL的概念

• AVL树是最先发明的⾃平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的⼆叉搜索树：它的左右⼦树都是AVL树，且左右⼦树的⾼度差的绝对值不超过1。AVL树是⼀颗⾼度平衡搜索⼆叉树，通过控制⾼度差去控制平衡。

• AVL树得名于它的发明者G.M.Adelson-Velsky和E.M.Landis是两个前苏联的科学家，他们在1962年的论⽂《An algorithm for the organization of information》中发表了它。

• AVL树实现这⾥我们引⼊⼀个平衡因⼦(balance factor)的概念，每个结点都有⼀个平衡因⼦，任何结点的平衡因⼦等于右⼦树的⾼度减去左⼦树的⾼度，也就是说任何结点的平衡因⼦等于0/1/-1，AVL树并不是必须要平衡因⼦，但是有了平衡因⼦可以更⽅便我们去进⾏观察和控制树是否平衡，就像⼀个⻛向标⼀样。

• 思考⼀下为什么AVL树是⾼度平衡搜索⼆叉树，要求⾼度差不超过1，⽽不是⾼度差是0呢？0不是更好的平衡吗？画画图分析我们发现，不是不想这样设计，⽽是有些情况是做不到⾼度差是0的。⽐如⼀棵树是2个结点，4个结点等情况下，⾼度差最好就是1，⽆法做到⾼度差是0。

• AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在logN ，那么增删查改的效率也可以控制在O(logN) ，相⽐⼆叉搜索树有了本质的提升。

二、AVL树的实现

1、AVL树的结构

template<class K, class V>
struct AVLTreeNode
{pair<K, V> _kv;//节点的值AVLTreeNode<K, V>* _left;AVLTreeNode<K, V>* _right;AVLTreeNode<K, V>* _parent;int _bf;//平衡因子AVLTreeNode(const pair<K, V>& kv):_kv(kv),_left(nullptr),_right(nullptr),_parent(nullptr)_bf(0){}
};template<class K,class V>
class AVLTree
{typedef AVLTreeNode<K, V> Node;
public://...private:Node* _root = nullptr;
};

2、AVL树的插⼊

1）AVL树的插⼊过程

1. 插⼊⼀个值按⼆叉搜索树规则进⾏插⼊。
2. 新增结点以后，只会影响祖先结点的⾼度，也就是可能会影响部分祖先结点的平衡因⼦，所以更新从新增结点->根结点路径上的平衡因⼦，实际中最坏情况下要更新到根，有些情况更新到中间就可以停⽌了，具体情况我们下⾯再详细分析。
3. 更新平衡因⼦过程中没有出现问题，则插⼊结束。
4. 更新平衡因⼦过程中出现不平衡，对不平衡⼦树旋转，旋转后本质调平衡的同时，本质降低了⼦树的⾼度，不会再影响上⼀层，所以插⼊结束。

2）平衡因⼦更新

更新原则：

• 平衡因⼦ = 右⼦树⾼度-左⼦树⾼度。
• 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
• 插⼊结点，会增加⾼度，所以新增结点在parent的右⼦树，parent的平衡因⼦++，新增结点在parent的左⼦树，parent平衡因⼦- -。
• parent所在⼦树的⾼度是否变化决定了是否会继续往上更新。

更新停⽌条件：

• 更新后parent的平衡因⼦等于0，说明parent的平衡因⼦变化为-1->0或者1->0，更新前parent⼦树⼀边⾼⼀边低，新增的结点插⼊在低的那边，插⼊后parent所在的⼦树⾼度不变，不会影响parent的⽗亲结点的平衡因⼦，更新结束。

• 更新后parent的平衡因⼦等于1或-1，说明parent的平衡因⼦变化为0->1或者0->-1，更新前parent⼦树两边⼀样⾼，新增的插⼊结点后，parent所在的⼦树⼀边⾼⼀边低，parent所在的⼦树符合平衡要求，但是⾼度增加了1，会影响parent的⽗亲结点的平衡因⼦，所以要继续向上更新。

• 更新后parent的平衡因⼦等于2或-2，说明parent的平衡因⼦变化为1->2或者-1->-2，更新前parent⼦树⼀边⾼⼀边低，新增的插⼊结点在⾼的那边，parent所在的⼦树⾼的那边更⾼了，破坏了平衡，parent所在的⼦树不符合平衡要求，需要旋转处理，旋转的⽬标有两个：1、把parent⼦树旋转平衡。2、降低parent⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不需要继续往上更新，插⼊结束。

• 不断更新，更新到根，根的平衡因⼦是1或-1也停⽌了。

更新到10结点，平衡因⼦为2，10所在的⼦树已经不平衡，需要旋转处理

更新到中间结点，3为根的⼦树⾼度不变，不会影响上⼀层，更新结束

最坏更新到根停⽌

3）AVL树插入的代码实现

bool insert(const pair<K, V>& kv)
{if (_root == nullptr){_root = new Node(kv);return true;}//找到要插入的空位Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_kv.first < kv.first){parent = cur;cur = cur->_right;}else if (cur->_kv.first > kv.first){parent = cur;cur = cur->_left;}else{return false;}}//插入到空位cur = new Node(kv);//确定插入位置并向下连接if (parent->_kv.first < kv.first){parent->_right = cur;}else{parent->_left = cur;}//向上连接cur->_parent = parent;//控制平衡while (parent){//插入节点会增加高度if (cur == parent->_left)parent->_bf--;elseparent->_bf++;if (parent->_bf == 0){break;}else if (parent->_bf == 1 || parent->_bf == -1){cur = parent;parent = parent->_parent;}else if (parent->_bf == 2 || parent->_bf == -2){//旋转break;}else{assert(false);}}return true;
}

3、旋转

1）旋转的原则

1. 保持搜索树的规则。
2. 让旋转的树从不满⾜变平衡，其次降低旋转树的⾼度。

旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。

2）右单旋

• 下图展⽰的是10为根的树，有a/b/c抽象为三棵⾼度为h的⼦树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是⼀个整棵树中局部的⼦树的根。这⾥a/b/c是⾼度为h的⼦树，是⼀种概括抽象表⽰，他代表了所有右单旋的场景，实际右单旋形态有很多种。

• 在a⼦树中插⼊⼀个新结点，导致a⼦树的⾼度从h变成h+1，不断向上更新平衡因⼦，导致10的平衡因⼦从-1变成-2，10为根的树左右⾼度差超过1，违反平衡规则。10为根的树左边太⾼了，需要往右边旋转，控制两棵树的平衡。

• 旋转核⼼步骤： 因为5 < b⼦树的值 < 10，将b变成10的左⼦树，10变成5的右⼦树，5变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的⾼度恢复到了插⼊之前的h+2，符合旋转原则。如果插⼊之前10是整棵树的⼀个局部⼦树，旋转后不会再影响上⼀层，插⼊结束了。

void RotateR(Node* parent)
{Node* subL = parent->_left;Node* subLR = subL->_right;Node* pParent = parent->_parent;parent->_left = subLR;if (subLR)//不能解引用空指针{subLR->_parent = parent;}subL->_right = parent;parent->_parent = subL;//更新根节点//如果原parent是根节点，不存在父节点if (pParent == nullptr){_root = subL;subL->_parent = nullptr;}else{//原parent在父节点的左边if (pParent->_left == parent){pParent->_left = subL;}else{pParent->_right = subL;}subL->_parent = pParent;}//更新平衡因子subL->_bf = 0;parent->_bf = 0;
}

3）左单旋

• 下图展⽰的是10为根的树，有a/b/c抽象为三棵⾼度为h的⼦树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是⼀个整棵树中局部的⼦树的根。这⾥a/b/c是⾼度为h的⼦树，是⼀种概括抽象表⽰，他代表了所有左单旋的场景，实际左单旋形态有很多种，具体跟上⾯右旋类似。

• 在a⼦树中插⼊⼀个新结点，导致a⼦树的⾼度从h变成h+1，不断向上更新平衡因⼦，导致10的平衡因⼦从1变成2，10为根的树左右⾼度差超过1，违反平衡规则。10为根的树右边太⾼了，需要往左边旋转，控制两棵树的平衡。

• 旋转核⼼步骤： 因为10 < b⼦树的值 < 15，将b变成10的右⼦树，10变成15的左⼦树，15变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的⾼度恢复到了插⼊之前的h+2，符合旋转原则。如果插⼊之前10是整棵树的⼀个局部⼦树，旋转后不会再影响上⼀层，插⼊结束了。
  

void RotateL(Node* parent)
{Node* subR = parent->_right;Node* subRL = subR->_left;Node* pParent = parent->_parent;parent->_right = subRL;if (subRL)subRL->_parent = parent;subR->_left = parent;parent->_parent = subR;if (pParent == nullptr){_root = subR;subR->_parent = nullptr;}else{if (pParent->_left == parent){pParent->_left = subR;}else{pParent->_right = subR;}subR->_parent = pParent;}//更新平衡因子subR->_bf = 0;parent->_bf = 0;
}

4）左右双旋

下图中如果在b子树中插入节点，只经过一次旋转是无法达到平衡的效果的，此时就需要进行两次旋转。同时由于在b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察8的平衡因⼦不同，从而分为三种情况：

• 场景1：h>=1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1并为h并不断更新8->5->10平衡因⼦，引发旋转： 先以5为旋转点进行左单旋，再以10为旋转点进行右单旋，最后e变成5的右边，f变成10的左边。其中8的平衡因⼦为-1，旋转后8和5平衡因⼦为0，10平衡因⼦为1。

• 场景2：h>=1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新8->5->10平衡因⼦，引发旋转：先以5为旋转点进行左单旋，再以10为旋转点进行右单旋，最后e变成5的右边，f变成10的左边。其中8的平衡因⼦为1，旋转后8和10平衡因⼦为0，5平衡因⼦为-1。

• 场景3：h==0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新5->10平衡因⼦，引发旋转：先以5为旋转点进行左单旋，再以10为旋转点进行右单旋，最后e变成5的右边，f变成10的左边。其中8的平衡因⼦为0，旋转后8和10和5平衡因⼦均为0。

void RotateLR(Node* parent)
{Node* subL = parent->_left;Node* subLR = subL->_right;//提前记录subLR的平衡因子int bf = subLR->_bf;RotateL(parent->_left);RotateR(parent);//更新平衡因子if (bf == -1){subLR->_bf = 0;subL->_bf = 0;parent->_bf = 1;}else if (bf == 1){subLR->_bf = 0;subL->_bf = -1;parent->_bf = 0;}else if (bf == 0){subLR->_bf = 0;subL->_bf = 0;parent->_bf = 0;}else{assert(false);}
}

5）右左双旋

跟左右双旋类似，下图中如果在b子树中插入节点，只经过一次旋转是无法达到平衡的效果的，此时就需要进行两次旋转。同时由于在b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察12的平衡因⼦不同，从而分为三种情况：

• 场景1：h>=1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，引发旋转： 先以15为旋转点进行右单旋，再以10为旋转点进行左单旋，e变成10的右边，f变成15的左边。其中12的平衡因⼦为-1，旋转后10和12平衡因⼦为0，15平衡因⼦为1。

• 场景2：h>=1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，引发旋转。其中12的平衡因⼦为1，旋转后15和12平衡因⼦为0，10平衡因⼦为-1。

• 场景3：h==0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新15->10平衡因⼦，引发旋转。其中12的平衡因⼦为0，旋转后10和12和15平衡因⼦均为0。

void RotateRL(Node* parent)
{Node* subR = parent->_right;Node* subRL = subR->_left;int bf = subRL->_bf;RotateR(parent->_right);RotateL(parent);if (bf == -1){subRL->_bf = 0;subR->_bf = 1;parent->_bf = 0;}else if (bf == 1){subRL->_bf = 0;subR->_bf = 0;parent->_bf = -1;}else if (bf == 0){subRL->_bf = 0;subR->_bf = 0;parent->_bf = 0;}else{assert(false);}
}

4、AVL树的查找

按⼆叉搜索树逻辑实现即可，搜索效率为O(logN)。

Node* Find(const K& key)
{Node* cur = _root;while (cur){if (cur->_kv.first < key){cur = cur->_right;}else if (cur->_kv.first > key){cur = cur->_left;}else{return cur;}}return nullptr;
}

5、AVL树的平衡检测

我们实现的AVL树是否合格，我们通过检查左右⼦树⾼度差的的程序进⾏反向验证，同时检查⼀下结点的平衡因⼦更新是否出现了问题。

int _Height(Node* root)
{if (root == nullptr){return 0;}int leftHeight = _Height(root->_left);int rightHeight = _Height(root->_right);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}bool _IsBalanceTree(Node* root)
{//空树也是AVL树if (root == nullptr){return true;}//计算pRoot节点的平衡因子:pRoot右左子树的高度差int leftHeight = _Height(root->_left);int rightHeight = _Height(root->_right);int diff = rightHeight - leftHeight;// 如果计算出的平衡因子与pRoot的平衡因子不相等，// 或者pRoot平衡因子的绝对值超过2，则一定不是AVL树if (abs(diff) >= 2){cout << root->_kv.first << "高度差异常" << endl;return false;}if (root->_bf != diff){cout << root->_kv.first << "平衡因子异常" << endl;return false;}// pRoot的左和右如果都是AVL树，则该树一定是AVL树return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}

6、AVL树实现的完整代码

1）AVLTree.h

#include<iostream>
#include<assert.h>
using namespace std;template<class K, class V>
struct AVLTreeNode
{pair<K, V> _kv;//节点的值AVLTreeNode<K, V>* _left;AVLTreeNode<K, V>* _right;AVLTreeNode<K, V>* _parent;int _bf;//平衡因子AVLTreeNode(const pair<K, V>& kv):_kv(kv),_left(nullptr),_right(nullptr),_parent(nullptr),_bf(0){}
};template<class K,class V>
class AVLTree
{typedef AVLTreeNode<K, V> Node;
public:	bool insert(const pair<K, V>& kv){if (_root == nullptr){_root = new Node(kv);return true;}//找到要插入的空位Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_kv.first < kv.first){parent = cur;cur = cur->_right;}else if (cur->_kv.first > kv.first){parent = cur;cur = cur->_left;}else{return false;}}//插入到空位cur = new Node(kv);//确定插入位置并向下连接if (parent->_kv.first < kv.first){parent->_right = cur;}else{parent->_left = cur;}//向上连接cur->_parent = parent;//控制平衡while (parent){//插入节点会增加高度if (cur == parent->_left)parent->_bf--;elseparent->_bf++;if (parent->_bf == 0){break;}else if (parent->_bf == 1 || parent->_bf == -1){cur = parent;parent = parent->_parent;}else if (parent->_bf == 2 || parent->_bf == -2){//旋转if (parent->_bf == -2 && cur->_bf == -1){RotateR(parent);}else if (parent->_bf == 2 && cur->_bf == 1) {RotateL(parent);}else if (parent->_bf == -2 && cur->_bf == 1){RotateLR(parent);}else if (parent->_bf == 2 && cur->_bf == -1){RotateRL(parent);}else{assert(false);}break;}else{assert(false);}}return true;}void RotateR(Node* parent){Node* subL = parent->_left;Node* subLR = subL->_right;Node* pParent = parent->_parent;parent->_left = subLR;if (subLR)//不能解引用空指针{subLR->_parent = parent;}subL->_right = parent;parent->_parent = subL;//更新根节点//如果原parent是根节点，不存在父节点if (pParent == nullptr){_root = subL;subL->_parent = nullptr;}else{//原parent在父节点的左边if (pParent->_left == parent){pParent->_left = subL;}else{pParent->_right = subL;}subL->_parent = pParent;}//更新平衡因子subL->_bf = 0;parent->_bf = 0;}void RotateL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;Node* pParent = parent->_parent;parent->_right = subRL;if (subRL)subRL->_parent = parent;subR->_left = parent;parent->_parent = subR;if (pParent == nullptr){_root = subR;subR->_parent = nullptr;}else{if (pParent->_left == parent){pParent->_left = subR;}else{pParent->_right = subR;}subR->_parent = pParent;}//更新平衡因子subR->_bf = 0;parent->_bf = 0;}void RotateLR(Node* parent){Node* subL = parent->_left;Node* subLR = subL->_right;//提前记录subLR的平衡因子int bf = subLR->_bf;RotateL(parent->_left);RotateR(parent);//更新平衡因子if (bf == -1){subLR->_bf = 0;subL->_bf = 0;parent->_bf = 1;}else if (bf == 1){subLR->_bf = 0;subL->_bf = -1;parent->_bf = 0;}else if (bf == 0){subLR->_bf = 0;subL->_bf = 0;parent->_bf = 0;}else{assert(false);}}void RotateRL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;int bf = subRL->_bf;RotateR(parent->_right);RotateL(parent);if (bf == -1){subRL->_bf = 0;subR->_bf = 1;parent->_bf = 0;}else if (bf == 1){subRL->_bf = 0;subR->_bf = 0;parent->_bf = -1;}else if (bf == 0){subRL->_bf = 0;subR->_bf = 0;parent->_bf = 0;}else{assert(false);}}void InOrder(){_InOrder(_root);cout << endl;}int Height(){return _Height(_root);}int Size(){return _Size(_root);}bool IsBalanceTree(){return _IsBalanceTree(_root);}Node* Find(const K& key){Node* cur = _root;while (cur){if (cur->_kv.first < key){cur = cur->_right;}else if (cur->_kv.first > key){cur = cur->_left;}else{return cur;}}return nullptr;}private:void _InOrder(Node* root){if (root == nullptr){return;}_InOrder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_InOrder(root->_right);}int _Height(Node* root){if (root == nullptr){return 0;}int leftHeight = _Height(root->_left);int rightHeight = _Height(root->_right);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}int _Size(Node* root){if (root == nullptr){return 0;}return _Size(root->_left) + _Size(root->_right) + 1;}bool _IsBalanceTree(Node* root){//空树也是AVL树if (root == nullptr){return true;}//计算pRoot节点的平衡因子:pRoot右左子树的高度差int leftHeight = _Height(root->_left);int rightHeight = _Height(root->_right);int diff = rightHeight - leftHeight;// 如果计算出的平衡因子与pRoot的平衡因子不相等，// 或者pRoot平衡因子的绝对值超过2，则一定不是AVL树if (abs(diff) >= 2){cout << root->_kv.first << "高度差异常" << endl;return false;}if (root->_bf != diff){cout << root->_kv.first << "平衡因子异常" << endl;return false;}// pRoot的左和右如果都是AVL树，则该树一定是AVL树return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);}private:Node* _root = nullptr;
};

2）Test.cpp

在这里测试一下实现的各种方法：

#include"AVLTree.h"void TestAVLTree1()
{AVLTree<int, int> t;int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };//常规测试用例//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };//带有双旋场景的测试用例for (auto e : a){t.insert({ e,e });}t.InOrder();cout << t.IsBalanceTree() << endl;}

运行结果：

#include<vector>
#include"AVLTree.h"void TestAVLTree2()
{//插入一堆随机值，测试平衡、高度和性能const int N = 1000000;vector<int> v;v.reserve(N);srand(time(0));for (size_t i = 0; i < N; i++){v.push_back(rand() + i);}//插入size_t begin1 = clock();AVLTree<int, int> t;for (auto e : v){t.insert(make_pair(e, e));}size_t end1 = clock();//查找size_t begin2 = clock();//确定的值//for (auto e : v)//{//	t.Find(e);//}//随机的值for (size_t i = 0; i < N; i++){t.Find(rand() + i);}size_t end2 = clock();cout << "Insert:" << end1 - begin1 << endl;cout << "Find:" << end2 - begin2 << endl;cout << "balance:" << t.IsBalanceTree() << endl;cout << "Height:" << t.Height() << endl;cout << "Size:" << t.Size() << endl;
}

运行结果：