小编在学习完AVL树之后觉得AVL树的底层逻辑原理不是很难，在实现AVL树的过程中可能在调整过程中经过旋转调整会有点难，但是小编可以给大家讲解清楚，结合旋转过程的详细解图，相信大家一定可以学会并且理解AVL树的底层逻辑原理及其实现，话不多说，进入学习！~~~
前导：
继上个博客大家学习完搜索二叉树之后，会发现在下面这种情况下，搜索二叉树的效率会大大降低，附图
所以今天我们学习AVL树就是为了解决这种一边倒的情况，让这棵树一直保持在两侧高度差不超过1，以此来提高查找的效率。
一、AVL树的底层逻辑原理
底层原理：插入的过程和搜索二叉树相同，但是保证每次插入一个节点两边的高度差不超过1，这样就是一个AVL树。
二、AVL树的实现原理
实现原理：通过对搜索二叉树的修改来实现AVL树，在实现AVL树的过程中，我们需要引入一个平衡因子来保证每次插入的过程，树两边的高度差仍然是一，再次还要引入一个节点的指针，引入一个父节点的指针(后面旋转有用会讲)，引入平衡因子之后就为我们对树进行旋转做了准备，这样就可以通过旋转来保证AVL树的高度差不超过1。
三、AVL树的实现过程
1、在了解AVL树的底层原理之后，大家肯定会对这个新增的平衡因子有疑惑，现在我来告诉大家这个平衡因子的作用，在这里先说一下平衡因子的作用：
平衡因子作用：平衡因子的作用就是为了记录子树两侧的高度差，当高度差大于1的时候就需要进行操作旋转(后面就会讲)，来保证树的高度差不超过1，也就是AVL树。
请看下图及其平衡因子的讲解(在这里我们规定右边高度为正，左边高度为负)：
因为每次新插入一个节点的时候，树两边的高度差会被改变，所以我们每次插入之后需要更新平衡因子，当平衡因子超过绝对值1之后，也就是高度差超过1之后，就会引出旋转，来保持树的平衡，来做到AVL树。
2、在了解到平衡因子的作用之后，大家先跟着我实现一下AVL树的基础结构，代码如下：
template<class T1, class T2>
struct AVLTreeNode
{
pair<T1,T2> _data;
struct AVLTreeNode<T1,T2>* _left;
struct AVLTreeNode<T1, T2>* _right;
struct AVLTreeNode<T1, T2>* _parent; // 存的是当前节点的父节点
int bf; // balance factor 记录的是当前位置的平衡因子
AVLTreeNode(const pair<T1,T2>& data)
:_data(data)
,_left(nullptr)
,_right(nullptr)
,bf(0) // 因为每次插入的这个节点左右子节点都为空，所以它的平衡因子为0
,_parent(nullptr)
{}
};3、接下来我们就来实现一下AVL树的节点插入过程，和搜索二叉树不同的是，在插入的过程中我们需要更新每个节点的平衡因子，并且为了后面树不平衡来进行旋转做准备。大家先看下面的图和注释先来了解如何更新平衡因子，这样方便我们来实现插入节点和更新平衡因子的过程：
在更新平衡因子的过程中，这里还有两种不同的情况，请看下图分析：
总结：在向上更新节点的平衡因子过程中，如果更新到哪个节点的平衡因子为0，就不再继续往上更新平衡因子，因为插入的这个节点不会影响到其他节点，只会影响到自己的父节点。
接下来就该讲到大家最期待的旋转过程了，虽然有点难，但是我会给大家讲清楚的，首先我们应该明白当平衡因子到什么情况下才需要进行旋转的过程，如下图和注释供大家参考和学习：
以上就是所有关于平衡因子的内容，接下来我们来讲解旋转的过程，也就是大家最期待的过程，看了上面大家已经明白了当平衡因子到达什么情况才需要进行旋转，在这里我直接告诉大家旋转方法，旋转有四种情况，我一一来告诉大家：
a、左单旋
b、右单旋
因为左单旋和右单旋的操作类似，所以在这里不在讲解，大家不理解的话请先理解左单旋，右单旋也就会了。
c、先左旋再右旋
d、先右旋再左旋
因为先左旋再右旋和先右旋再左旋的操作类似，所以在这里不在讲解，大家不理解的话请先理解先左旋再右旋，先右旋再左旋也就会了。
总结：
1、左、右单旋：当即将旋转的时候，平衡因子为同号的话就只需要进行单旋即可。
2、先左、右单旋，再右、左单旋：当即将旋转的时候，平衡因子为异号的话就只需要进行双旋。
可能大家会有点疑惑，同号和异号有什么区别，所以我在这块给大家准备了图和注释，相信大家很容易就可以理解：
明白了上面这些，请大家和我一起实现一下节点插入的操作：
bool Insert(const pair<T1, T2>& x)
{
// 第一次插入节点
if (_root == nullptr)
{
_root = new Node(x);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_data.first < x.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_data.first > x.first)
{
parent = cur;
cur = cur->_left;
}
else
{
// 走到else说明搜索二叉树里面有这个值，所以就不用插入
return false;
}
}
if (parent->_left == cur && parent->_data.first > x.first) // 确定插入的值在哪边
{
parent->_left = new Node(x);
parent->_left->_parent = parent;
cur = parent->_left;
}
else
{
parent->_right = new Node(x);
parent->_right->_parent = parent;
cur = parent->_right;
}
// 更新 bf 的操作
while (parent)
{
if (parent->_left == cur && (parent->bf == 0 || parent->bf == 1))
{
parent->bf--;
}
else if (parent->_right == cur && (parent->bf == 0 || parent->bf == -1))
{
parent->bf++;
}
else // 走到这块说明平衡因子为 2 或者 -2
{
// 旋转
if (parent->_right == cur && parent->bf == 1 && cur->bf == 1)
{
// 左单旋
RotateL(parent);
}
else if (parent->_left == cur && parent->bf == -1 && cur->bf == -1)
{
// 右单旋
RotateR(parent);
}
else if (parent->_left == cur && parent->bf == -1 && cur->bf == 1)
{
// 先左旋在右旋
RotateLR(parent);
}
else if (parent->_right == cur && parent->bf == 1 && cur->bf == -1)
{
// 先右旋在左旋
RotateRL(parent);
}
else
{
assert(false);
}
break;
}
if (parent->bf == 0) // 当平衡因子更新完等于 0 之后 便不再向上继续调整
break;
cur = parent;
parent = parent->_parent;
}
return true;
}
// 左单旋
void RotateL(Node* parent)
{
Node* parent_Parent = parent->_parent; // 记录此时根节点的父节点 为后面判断是子树还是根做准备
Node* subR = parent->_right;
Node* subRL = subR->_left;
// 左单旋的操作 连接起来节点 并且改变父节点
parent->_right = subRL;
if(subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
if (parent_Parent == nullptr) // 说明这个节点就为根节点
{
_root = subR;
subR->_parent = nullptr;
}
else // 说明这个节点只是一个子树的节点
{
if (parent_Parent->_left == parent)
parent_Parent->_left = subR;
else
parent_Parent->_right = subR;
subR->_parent = parent_Parent;
}
subR->bf = parent->bf = 0; // 改变这些地方的平衡因子
}
// 右单旋
void RotateR(Node* parent)
{
Node* parent_Parent = parent->_parent;
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if(subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
if (parent_Parent == nullptr)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parent_Parent->_left == parent)
parent_Parent->_left = subL;
else
parent_Parent->_right = subL;
subL->_parent = parent_Parent;
}
subL->bf = parent->bf = 0;
}
// 先左旋再右旋
void RotateLR(Node* parent)
{
Node* SubL = parent->_left;
Node* SubLR = SubL->_right;
int bf = SubLR->bf;
RotateL(parent->_left);
RotateR(parent);
// 更新平衡因子
if (bf == 0) // 处理 h == 0 的情况
{
parent->bf = 0;
SubL->bf = 0;
}
else if (bf == 1) // 后面的是处理 h > 0 的情况
{
parent->bf = 0;
SubL->bf = -1;
}
else if(bf == -1)
{
SubL->bf = 0;
parent->bf = 1;
}
else
{
assert(false);
}
SubLR->bf = 0;
}
// 先右旋再左旋
void RotateRL(Node* parent)
{
Node* SubR = parent->_right;
Node* SubRL = SubR->_left;
int bf = SubRL->bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == 0)
{
SubR->bf = 0;
SubRL->bf = 0;
parent->bf = 0;
}
else if (bf == 1)
{
SubR->bf = 0;
SubRL->bf = 0;
parent->bf = -1;
}
else if (bf == -1)
{
SubR->bf = 1;
SubRL->bf = 0;
parent->bf = 0;
}
else
{
assert(false);
}
}
好了以上就是今天最难的部分，相信大家看完这部分肯定会收获满满。
4、接下来就是AVL树的遍历和AVL树的销毁部分，这部分和搜索二叉树一样，我就不在这里做详细讲解了，大家如果有什么不理解的可以评论区留言或者私信我，我帮大家解答，代码及注释我就放到下面了，供大家参考：
// 查找二叉树的中序遍历刚好是顺序排序
void InOrder()
{
// 中序遍历需要递归来解决，所以这个 _root 不好传 如果直接用_root 的话 _root 就会被改变
Node* cur = _root;
_InOrder(cur);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left);
cout << root->_data.first << ":" << root->_data.second << endl;
_InOrder(root->_right);
}
~AVLTree()
{
// 后序删除空间 左 右 根
_AVLTreeDestory(_root);
_root = nullptr;
}
void _AVLTreeDestory(Node* root)
{
if (root == nullptr)
return;
_AVLTreeDestory(root->_left);
_AVLTreeDestory(root->_right);
delete root;
}5、为了验证自己写的AVL树是否满足条件，也就是否高度差为1，所以对于AVL树我们还有其他操作，比如树的高度，树的节点的计算方法，这里和初阶的二叉树的求解方法一样，所以我不在做详细解答，如果大家有什么不会的，可以评论区留言，或者私信我，代码及注释我放到下面了，供大家参考：
// 节点个数
int Size()
{
return _size(_root);
}
// 树的高度
int Height()
{
return _Height(_root);
}
int _size(Node* root)
{
if (root == nullptr)
return 0;
return _size(root->_left) + _size(root->_right) + 1;
}
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;
}
// 判断是否为AVL树
bool IsAVLTree()
{
return _IsAVLTree(_root);
}
bool _IsAVLTree(Node* root)
{
if (root == nullptr)
return true;
// 判断每一棵子树是否为AVL树
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
// 如果高度差大于1就说明不满足AVL树的底层原理
if (abs(diff) > 1)
return false;
return _IsAVLTree(root->_left) && _IsAVLTree(root->_right);
}
好啦，以上就是今天的所有内容，相信大家看完一定会收获满满，我们下次再见！~~~~
![[论文阅读]JTORO in NOMA-based VEC:A game-theoretic DRL approach](https://i-blog.csdnimg.cn/direct/b9d438256c714fa093fa18e46f2f8391.png)
![World of Warcraft [CLASSIC][80][Grandel]Sapphire Hive Drone](https://i-blog.csdnimg.cn/direct/895a93c84eeb43a98e1c98258553d409.jpeg)
