目录
一、前言
二叉搜索树以二叉树为原生结构，在此基础上增加了根、左子树结点、右子树结点的大小关系，在数据的增删查和算法中都有较广泛的应用，然而在极端情况下，二叉搜索树可能会退化成链式结构，时间复杂度退化为O(N)，此时二叉搜索树的查找效率大大降低，因此就有必要控制二叉搜索树结构的平衡，使其左右子树分布尽可能均匀，从而使效率维持在O(logN)附近，AVL树就是一种平衡二叉搜索树，AVL树通过控制左右子树的高度差来实现二叉搜索树的平衡，本文将围绕AVL树结构展开介绍，以AVL树结构为出发点，由浅入深，从结构特点到AVL树的查找插入，其中AVL树的插入较为复杂，涉及到平衡因子的更新、旋转相关问题，本文将详细展开介绍，AVL树整体结点数量和分布与完全二叉树类似，其高度维持在logN左右，故增删查改的效率都为O(logN)，相比二叉搜索树性能有了本质的提升。
二、AVL树
1、结构
AVL树为平衡二叉搜索树，其左右子树也都为AVL树，且AVL树的左右子树高度差的绝对值不超过1，AVL树通过控制左右子树的高度差来实现结构平衡。
上图所示就是AVL树，在二叉搜索树的结构基础上对左右子树的高度进行了平衡，左右子树高度差的绝对值不超过1，其左子树和右子树也都为AVL树，AVL树这里引入一个平衡因子的概念，每个结点都有一个平衡因子，结点的平衡因子等于其右子树的高度减去左子树的高度，可知在AVL树中结点的平衡因子大小为-1/0/1，AVL树实现并不是一定要有平衡因子，但有了平衡因子可以方便观察和控制树是否平衡，上例AVL树的平衡因子如下图所示：
引入了平衡因子，那么AVL树插入数据后就需更新每个结点的平衡因子，以此观察树是否平衡，对此在AVL树结点中增加了parent指针，parent指针指向该结点的双亲结点，这样就可以通过parent指针由下往上更新相关结点的平衡因子，从而完成平衡因子的更新。
2、结点
AVL树实现为key_value搜索场景平衡二叉搜索树的模板类型，结点存放的数据类型为pair类型，即pair<K，V> _kv。
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)
{
}
};K为key的数据类型，V为value的数据类型，_left、_right为结点左右孩子指针，_parent为双亲结点指针，用于平衡因子的更新，_bf为该结点的平衡因子，结点构造函数通过传pair<K，V> kv对象进行构造，pair类型成员变量_kv初始化为kv，_left、_right、_parent初始化为nullptr，结点左右子树初始均为空，故结点的平衡因子_bf初始化为0，这样就实现了AVL树结点的构造。
3、查找
template<class K, class V>
class AVLtree
{
using Node = AVLtreenode<K, V>;
public:
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:
Node* _root = nullptr;
};
using Node=AVLtreenode<K,V>，将结点重命名为Node，AVL树成员变量Node*根结点_root初始化为nullptr，find用于AVL树数据key的查找，与二叉搜索树的查找规则一致，cur初始化为_root，通过while循环，比较cur->_kv.first与key的大小关系，若cur->_kv.first小于key，则cur往右子树方向继续遍历，即cur=cur->_right，若cur->_kv.first大于key，则cur往左子树方向继续遍历，即cur=cur->_left，else则查找成功，即cur->_kv.first==key，return cur，while循环结束，则cur为nullptr，没找到key，查找失败，return nullptr。
4、中序
template<class K, class V>
class AVLtree
{
using Node = AVLtreenode<K, V>;
public:
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;
}
void Inorder()
{
_Inorder(_root);
cout << endl;
}
private:
void _Inorder(Node* root)
{
if (root == nullptr)
return;
_Inorder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_Inorder(root->_right);
}
private:
Node* _root = nullptr;
};
AVL树中序遍历与二叉搜索树中序遍历的规则一致，通过递归实现中序遍历，递归返回条件为root==nullptr，先递归遍历左子树，即_Inorder(root->_left)，再访问根，即访问pair的first、second成员，cout<<root->_kv.first<<":"<<root->_kv.second<<endl，再递归遍历根的右子树，即_Inorder(root->_right)，就完成了AVL树的中序遍历，这里还需注意的是_root为private成员，类外不能直接访问，类内部可以访问，因此就需在类内实现一个成员函数Inorder通过访问_root、调用_Inorder函数来完成中序遍历，那么类外就可以通过调用Inorder函数来完成AVL树的中序遍历。
5、高度
template<class K, class V>
class AVLtree
{
using Node = AVLtreenode<K, V>;
public:
int Height()
{
return _Height(_root);
}
private:
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;
}
private:
Node* _root = nullptr;
};
求AVL树的高度，也可以通过递归实现，先递归求出左子树的高度，再递归求出右子树的高度，递归返回条件为当root==nullptr，return 0 ，最后取左子树、右子树高度的较大值再加上根，即leftheight>rightheight?leftheight+1：rightheight+1，这样就递归求出了AVL树的高度，与中序遍历类似，类外不能直接访问_root，因此也需在类内实现成员函数Height通过访问_root、调用_Height来求出树的高度，那么类外就可以通过调用Height函数来求出树的高度。
6、结点数
template<class K, class V>
class AVLtree
{
using Node = AVLtreenode<K, V>;
public:
int size()
{
return _size(_root);
}
private:
int _size(Node* root)
{
if (root == nullptr)
return 0;
int leftsize = _size(root->_left);
int rightsize = _size(root->_right);
return leftsize + rightsize + 1;
}
private:
Node* _root = nullptr;
};
求AVL树的结点数，与上面类似，先递归求出左子树的结点数，再递归求出右子树的结点数，总结点数就是左子树结点数+右子树结点数+根结点，即leftsize+rightsize+1，递归返回条件为root==nullptr，也需在类内实现成员函数size访问_root、调用_size来求出树的结点数，类外就可以直接调用size来求出树的结点数。
7、判断是否为AVL树
template<class K, class V>
class AVLtree
{
using Node = AVLtreenode<K, V>;
public:
bool IsAVLtree()
{
return _IsAVLtree(_root);
}
private:
int _Getheight(Node* root)
{
if (root == nullptr)
return 0;
int leftheight = _Getheight(root->_left);
if (leftheight == -1)
{
return -1;
}
int rightheight = _Getheight(root->_right);
if (rightheight == -1)
{
return -1;
}
int diff = rightheight - leftheight;
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return -1;
}
if (root->_bf != diff)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return -1;
}
return max(leftheight, rightheight) + 1;
}
bool _IsAVLtree(Node*root)
{
return _Getheight(root) != -1;
}
private:
Node* _root = nullptr;
};
判断是否为AVL树，可通过左右子树的高度差来判断，_Getheight用于求出左右子树的高度差，并进行判断，采取后序遍历的方式对树进行递归，先递归求出左子树的高度，再递归求出右子树的高度，两者作差进行比较，若高度差绝对值大于等于2，即abs(diff)>=2，则该树不为AVL树，return -1，也可顺便检查平衡因子是否异常，若高度差diff不等于平衡因子，则平衡因子异常，return -1，若为AVL树，则返回该子树的高度，即max(leftheight，rightheight）+1，后序方式判断的好处是先判断左子树，再判断右子树，并保存了左右子树的高度，最后判断根就无需再重复计算一遍左右子树的高度，直接两者作差即可，即若该树为AVL树，则返回该树的高度，若不为AVL树，则返回-1，_IsAVLtree通过_Getheight的返回值即可判断是否为AVL树，若不为AVL树，则_Getheight==-1，即return _Getheight(root)！=-1，同理也需在类内实现成员函数IsAVLtree访问_root，调用_IsAVLtree来完成AVL树的判断，类外通过调用成员函数IsAVLtree来判断是否为AVL树。
8、插入
（1）结点插入
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;
return true;
}若起始树为空，则直接将结点插入即可，_root=new Node(kv)，若不为空，则按二叉搜索树的比较路线，cur初始化为_root，parent初始化为nullptr，parent用于保存cur的位置，便于后续结点指针的连接，通过while循环，若cur->_kv.first小于kv.first，则cur往右子树方向继续遍历，即paren=cur，cur=cur->_right，若cur->_kv.first大于kv.first，则cur往左子树方向继续遍历，即parent=cur，cur=cur->_left，不支持key相等数据的插入，else则cur->_kv.first==kv.first，插入失败，return false，遍历完成后，cur来到相应的位置，比较parent与cur的key，若parent->_kv.first<kv.first，则新增结点应为parent的右孩子，反之则为左孩子，最后还需处理_parent指针，即cur的_parent指针指向parent，即cur->_parent=parent，return true，就完成了结点的插入。
（2）平衡因子更新
<1> 含义
新增结点以后，会影响祖先结点的高度，也就是可能会影响部分祖先结点的平衡因子，因此需要更新从新增结点到根结点路径上的平衡因子，更新平衡因子过程中没有出现问题，即更新后的平衡因子都为-1/0/1，则插入结束，若更新平衡因子过程中出现不平衡，那么就需要对不平衡子树旋转，旋转调平衡的同时，本质也降低了子树的高度，不会再影响上一层，插入结束。
<2> 更新原则
1、平衡因子=右子树高度-左子树高度
2、只有子树高度变化才会影响当前结点的平衡因子
3、插入结点，会增加高度，若新增结点在parent的右子树，则parent的平衡因子++，新增结点在parent的左子树，parent的平衡因子--。
4、parent所在子树的高度是否变化决定了是否会继续往上更新。
<3> 更新停止条件
1、若更新后parent的平衡因子等于0，则更新之前parent的平衡因子为-1或1，说明更新前parent子树一边高一边低，新增结点插入在低的那边，插入后parent所在的子树高度不变，不会影响parent结点以上的平衡因子，更新结束，如结点6插入结点7：
则6的平衡因子从-1->0，可知结点6所在的子树高度不变，不影响结点6以上结点的平衡因子，平衡因子更新结束。
2、更新后parent的平衡因子等于1或-1，则更新中parent的平衡因子变化为0->1或0->-1，说明更新前parent子树两边一样高，新增的结点插入后，parent所在的子树一边高一边低，parent所在的子树符合平衡要求，但高度增加了1，会影响parent以上结点的平衡因子，要继续往上更新，如结点13后插入结点12：
则结点13的平衡因子由0->-1，这时结点13所在的子树高度发生了变化，需要继续向上更新平衡因子，可知结点10的平衡因子由1->2。
3、更新后parent的平衡因子等于2或-2，说明更新中parent的平衡因子由1->2或-1->-2，说明更新前parent子树一边高一边低，新增的插入结点在高的那边，破坏了平衡，故parent所在的子树不符合平衡要求，需要旋转处理，如结点10的平衡因子为2，故需要对10所在的子树进行旋转，旋转的目的有两个：第1是把10所在的子树旋转平衡，第2是降低10所在子树的高度，恢复到插入结点以前的高度，因此旋转后也不需要继续向上更新平衡因子，插入结束。
parent通过while循环完成平衡因子的更新：
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 (parent->_left == cur)
{
parent->_bf--;
}
else
{
parent->_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)
{
//旋转
}
}
return true;
}若cur为parent的左孩子，则parent的平衡因子--，若cur为parent的右孩子，则parent的平衡因子++，再判断parent的平衡因子，若parent->_bf==0，则无需继续向上更新平衡因子，break跳出循环，插入结束；若parent->_bf==-1或parent->_bf==1，则需继续向上更新平衡因子，即cur=parent，parent=parent->_parent，若parent->_bf==2或parent->_bf==-2，则parent所在子树不平衡，需要对其旋转。
（3）旋转
<1> 原则
旋转需保持搜索树的规则，让旋转的树从不平衡变平衡，其次降低旋转树的高度。
<2> 左单旋
为方便概括左单旋的所有场景，将a/b/c抽象为高度为h的子树，a/b/c均为AVL树，9可以是整个树的根，也可以是某个局部子树的根，在a子树中插入一个新结点，如下图所示：
a子树的高度从h变为h+1，可知以13为根的子树和以9为根的树都是右子树比左子树高，这种情况采取左单旋，向上更新平衡因子，13的平衡因子从0变为1，9的平衡因子从1变为2，9为根的树左右高度差超过1，显然不平衡了，9为根的右子树过高，需要往左边旋转，控制平衡。
左单旋核心步骤：由于9<b<13，因此可以将b变为9的右子树，9变为13的左子树，13变成该树新的根，如下图所示：
可知左单旋后仍符合搜索树的规则，同时控制了平衡，树的高度恢复到插入之前的h+2，符合旋转降低高度的原则，如果插入之前9为某个局部的子树，那么旋转后不会再影响上一层，插入结束。
代码实现：
左单旋需要处理subR、parent、subRL三者左右孩子指针、parent指针的指向问题，由上图可知
parent的_right指针指向subRL，即parent->_right=subRL，subRL可能为空，若subRL不为空，则subRL的_parent指针指向parent，即subRL->_parent=parent。
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
{
subRL->_parent = parent;
}
Node* pparent = 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;
}
parent->_bf = 0;
subR->_bf = 0;
}再处理subR结点与parent结点的连接问题，可知旋转后parent为subR的左孩子，即subR->_left=parent，parent的_parent指针指向subR，即parent->_parent=subR，这里还需注意的是parent可能为某个局部子树的根，因此还需处理parent的_parent指针所指向的结点，Node*pparent=parent->_parent，若pparent为空，则subR为新的根，即_root=subR，subR->_parent=nullptr，若pparent不为空，则先判断pparent与parent的关系，若parent为pparent的左孩子，则subR为pparent的左孩子，反之则为右孩子，subR的_parent指针指向pparent，即subR->_parent=pparent，最后还需更新平衡因子，可知旋转后parent、subR的平衡因子都为0，即parent->_bf=0，subR->_bf=0，左单旋完成。
<3> 右单旋
右单旋与左单旋类似，为方便表示右单旋的所有场景，将a/b/c抽象为高度为h的子树，在a子树中插入一个新结点，如下图所示：
a子树高度由h变为h+1，可知以9为根的子树和以13为根的树都是左子树比右子树高，这种情况采取右单旋，向上更新平衡因子，结点9的平衡因子由0更新为-1，结点13的平衡因子由-1更新为-2，即以13为根的树不平衡了，左子树偏高，需要进行右单旋，以控制树的平衡。
右单旋步骤与左单旋类似，由于9<b<13，故可将b变为13的左子树，13变为9的右子树，9作为该树新的根，如下图所示：
可知右单旋后仍符合搜索树的规则，同时控制了平衡，树的高度降低为插入之前的h+2，如果插入之前13为某个局部子树的根，那么旋转后也不会再影响上一层，插入结束。
代码实现：
与左单旋类似，右单旋需处理parent、subl、sublr三者指针的连接问题，parent的_left指针
void RotateR(Node* parent)
{
Node* subl = parent->_left;
Node* sublr = subl->_right;
parent->_left=sublr;
if (sublr)
{
sublr->_parent = parent;
}
Node* pparent = parent->_parent;
subl->_right = parent;
parent->_parent = subl;
if (parent == _root)
{
_root=subl;
subl->_parent = nullptr;
}
else
{
if (pparent->_left == parent)
{
pparent->_left = subl;
}
else
{
pparent->_right = subl;
}
subl->_parent = pparent;
}
subl->_bf = 0;
parent->_bf = 0;
}指向sublr，同理需要判断sublr是否为空，若sublr不为空，则sublr的_parent指针指向parent，subl的_right指针指向parent，parent的_parent指针指向subl，也需讨论parent是否为整个树的根，若parent为根，即parent==_root，则右单旋后subl为整个树的根，即_root=subl，subl->_parent=nullptr，若parent为某个局部子树的根，则需讨论parent为左孩子、右孩子的情况，旋转后subl为相应的孩子结点，subl的_parent指针指向pparent，即subl->_parent==pparent，最后更新平衡因子，可知右单旋后subl、parent的平衡因子都为0，即subl->_bf=0，parent->_bf=0，右单旋完成。
<4> 左右双旋
当树和子树的较高子树不一致时，这种情况下就需采取双旋，双旋有两种方式，先以左右双旋为例：
在c子树中插入一个结点，c子树高度由h-1变为h，结点11的平衡因子由0更新为1，可知11的右子树比左子树高，继续向上更新，结点9的平衡因子由0更新为1，结点9的右子树比左子树高，继续向上更新，结点13的平衡因子由-1变为-2，与结点9、11不同的是，结点13的左子树比右子树高，这种情况下采取左右双旋，先对以9为根的子树进行左单旋：
左单旋后b变成9的右子树，9变成11的左子树，11为该子树新的根，左单旋后以11为根的子树和以13为根的树都是左子树比右子树高，11的平衡因子更新为-1,13的平衡因子更新为-2，接下来对13进行右单旋：
右单旋后c变为13的左子树，13变为11的右子树，11作为整个树的根，右单旋后结点13的平衡因子由-2变为0，结点9的平衡因子为-1保持不变，结点11的平衡因子由-1变为0，可知左右双旋后，树恢复平衡，且符合搜索树的规则，树的高度恢复为插入之前的h+2，如果插入之前13为某个局部子树的根，那么左右双旋后也不会再影响上一层，插入结束。这是在c子树插入结点的情况，另一种情况是在b子树插入结点，与c子树插入结点方法类似，也是采取左右双旋来实现平衡，结果如下图所示：
与c子树插入结点不同的是平衡因子的大小，c中插入结点由以上分析可知，parent、subLR的平衡因子为0，subL的平衡因子为-1。在b中插入结点，subL、subLR的平衡因子都为0，parent的平衡因子为1。
第3种情况：当a、b、c、d都为空树
这时左右双旋后parent、subL、subLR的平衡因子都为0。
代码实现：
左右双旋即先对根的左子树左单旋，左单旋函数前面已实现，可直接调用，即RotateL(parent->_left)
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == -1)
{
subLR->_bf = 0;
parent->_bf = 1;
subL->_bf = 0;
}
else if(bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
subLR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = subL->_bf = subLR->_bf = 0;
}
else
{
assert(false);
}
}左单旋完成后，再对根右单旋，右单旋函数前面已实现，可直接调用，即RotateR(parent)，左右双旋完成后，对平衡因子进行更新，可通过subLR的平衡因子大小来讨论左右双旋的3种情况，当bf==-1，即在b子树中插入，则subLR、subL的平衡因子为0，parent的平衡因子为1，当bf==1，即在c子树中插入，则subLR、parent的平衡因子为0，subL的平衡因子为-1，当bf==0，即第3种情况，则parent、subL、subLR的平衡因子都为0，除以上3种情况之外，其他情况均为异常，断言报错，assert(false)。
<5> 右左双旋
与左右双旋类似，在b子树中插入结点后，导致以parent为根的树不平衡，右子树偏高，平衡因子为2，以subR为根的子树左边高，平衡因子为-1，这种情况下采取右左双旋来实现树的平衡，以13为根的子树先进行右单旋，接着以9为根的树进行左单旋，结果如下所示：
右左双旋后，9变为11的左子树，13变为11的右子树，11为整棵树新的根，parent、subRL的平衡因子为0，subR的平衡因子为1，可知旋转后树已恢复平衡，符合搜索树的规则，且高度降低为插入之前的h+2，如果插入之前9为某个局部子树的根，则右左双旋后也不会再影响上一层，插入结束。这是在b子树插入结点的情况，若在c子树中插入，与b类似，也是通过右左双旋来实现平衡，结果如下图所示：
c中插入结点与b中插入结点结果也是平衡因子的不同，可知c中插入结点，subR、subRL的平衡因子为0，parent的平衡因子为-1。
第3种情况：当a/b/c/d均为空树时：
这时右左双旋后，parent、subR、subRL的平衡因子都为0。
代码实现：
右左双旋步骤：先对parent的右子树进行右单旋，右单旋函数前面已实现，直接调用即可，即
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == -1)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1)
{
subRL->_bf = 0;
parent->_bf = -1;
subR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = subR->_bf = subRL->_bf = 0;
}
else
{
assert(false);
}
}RotateR(parent->_right)，再对以parent为根的树进行左单旋，左单旋函数前面已实现，即RotateL(parent)，这样就完成了右左双旋，最后进行平衡因子的更新，以subRL的平衡因子为标准对3种情况进行判断，若bf==-1，则是在b中插入结点，则subRL、parent的平衡因子为0，subR的平衡因子为1，若bf==1，则是在c中插入结点，则subRL、subR的平衡因子为0，parent的平衡因子为-1，若bf==0，则对应a/b/c/d均为空树，则parent、subR、subRL的平衡因子为0，其他情况则为异常，需断言报错，即assert(false)。
（4）插入完整实现
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 (parent->_left == cur)
{
parent->_bf--;
}
else
{
parent->_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;
}实现AVL树旋转的4种场景后，就可以完整实现AVL树的插入了，当parent->_bf==-2 && cur->_bf==-1时，说明parent和cur都为左子树偏高，采取右单旋，即RotateR(parent)，当parent->_bf==2 && cur->_bf==1时，说明parent和cur都为右子树偏高，采取左单旋，即RotateL(parent)，当parent->_bf==-2 && cur->_bf==1时，说明parent左子树偏高不平衡，cur右子树高，采取左右双旋，即RotateLR(parent)，当parent->_bf==2 && cur->_bf==-1时，说明parent右子树偏高不平衡，cur左子树高，采取右左双旋，即RotateRL(parent)，除以上情况，其他情况均为异常，断言报错，即assert(false)。
9、测试
(1) 结构测试
#include"AVLtree.h"
void TestAVLtree1()
{
int arr[] = {16,3,7,11,9,26,18,14,15};
AVLtree<int, int> t;
for (auto e : arr)
{
t.insert({ e,e });
}
t.Inorder();
cout << t.IsAVLtree() << endl;
}
int main()
{
TestAVLtree1();
return 0;
}AVLtree<int，int> t，通过范围for将arr数据逐个插入，即t.insert({e,e})，t.Inorder()，进行中序遍历，则结果应为升序，通过t.IsAVLtree()判断是否为AVL树，结果如下：
数据为升序，且该树为AVL树，结果正确，测试通过。
(2) 性能测试
void TestAVLtree2()
{
const int N = 100000;
vector<int> v1;
v1.reserve(N);
srand(time(0));
for (size_t i = 0;i < N;i++)
{
v1.push_back(rand() + i);
}
size_t begin2 = clock();
AVLtree<int, int> t;
for (auto e : v1)
{
t.insert(make_pair(e,e));
}
size_t end2 = clock();
cout << "insert:"<<end2 - begin2 << endl;
cout << t.IsAVLtree() << endl;
cout << "height:" << t.Height() << endl;
cout << "size:" << t.size() << endl;
size_t begin1 = clock();
for (size_t i = 0;i < N;i++)
{
t.find((rand() + i));
}
size_t end1 = clock();
cout << "find:" << end1 - begin1 << endl;
}对已实现的AVL树进行性能测试，检测其插入、查找性能，将一个容量为100000的vector容器数据插入到t中，srand(time(0))，v1.push_back(rand()+i)，数据均为随机数，t.find((rand()+i))，用于AVL树数据的查找，end1-begin1、end2-begin2用于获取查找、插入完成的时间，结果如下：
由于随机数可能重复，且不支持相等数据的插入，总结点数为66556，AVL树的高度为19，插入只需0.1s，查找79ms，由此可见AVL树强大的数据处理能力了。
三、结语
AVL树在二叉搜索树的结构基础上进行了优化，控制了左右子树的平衡，左右子树的高度差不超过1，通过引入平衡因子，可以方便观察AVL树的结构与左右子树的平衡，每个结点都有一个平衡因子，平衡因子大小为右子树与左子树的高度差，AVL树的插入需更新平衡因子，对此在结点中引入了_parent指针用于平衡因子的更新，当平衡因子更新为0时，不再往上更新，插入结束，平衡因子为-1或1时，需继续向上更新，平衡因子为-2或2时，说明该子树已经不平衡了，需要进行旋转，旋转分为左单旋、右单旋、左右双旋、右左双旋4种情况，旋转使树结构平衡的同时，本质也降低了树的高度，旋转后不会再影响上一层的结点，旋转完成后，插入就结束了，AVL树平衡的实现并不是静态的，而是每次插入后进行动态调整实现的，AVL树正是凭借其独特的平衡结构和动态调整能力，保证了最坏情况下O(logN)的查找、插入，AVL树结构的实现，正是平衡智慧的完美诠释！
扫一扫
352
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
