一、AVL树的概念
根据二叉搜索树中的内容，我们知道二叉搜索树虽然可以缩短查找的效率，但是如果数据有序或者接近有序二叉搜索树就会退化成单支树，或者退化成链表，相当与在链表中查找数据效率低下。因此，诞生了一种能够保证平衡的二叉搜索树 – AVL树，向二叉搜索树中插入节点后，通过对树中的节点进行调整，保证每个节点的左右子树之差的绝对值不超过1，这样就可以降低树的高度，从而减少平均搜索次数。
AVL树具备以下的两点性质：
- 它的左右子树都是AVL树
- 左右子树的高度之差（简称平衡因子）的绝对值不超1
平衡因子计算方法：abs(右子树高度 - 左子树高度)
一个二叉搜索树，如果它的高度是平衡的，那么它就是一个AVL树，如果它有n个节点，高度保持在log2N，搜索所用的时间复杂度就是O(logN)
二、AVL树节点的定义
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)
{}
};
构造函数：
强制使用默认生成的构造函数：
AVLTree() = default;
拷贝构造：
AVLTree(const AVLTree<K, V>& t)
{
_root = Copy(t._root);
}
Node* Copy(Node* root)
{
if (root == nullptr)
{
return nullptr;
}
Node* NewRoot = new Node(root->_kv);
NewRoot->_parent = root->_parent;
NewRoot->_bf = root->_bf;
NewRoot->_left = Copy(root->_left);
NewRoot->_right = Copy(root->_right);
return NewRoot;
}
赋值重载：
AVLTree<K, V>& operator=(AVLTree<K, V> t)
{
swap(_root, t._root);
return *this;
}
析构函数：
~AVLTree()
{
Destroy(_root);
_root = nullptr;
}
void Destroy(Node* root)
{
if (root == nullptr)
return;
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
三、AVL树的插入
AVL树就是在二叉搜索树的基础上加上了平衡因子，因此AVL树也可以看成是二叉搜索树，AVL树的插入过程可以分为以下两步：
- 按照二叉搜索树的方式插入新节点
- 调整节点的平衡因子
分析：
插入节点会影响部分祖先节点的平衡因子，因此要进行更新平衡因子。
更新平衡因子：
是否继续向上更新祖先节点，要看parent所在子树的高度是否发生变化：
1.parent平衡因子 == 0， 说明更新前parent平衡因子为1 / -1， parent所在子树的高度不变，不需要向上更新
2.parent平衡因子 == 1 / -1， 说明更新前parent的平衡因子 == 0， 插入在任意一遍parent所在子树的高度都会变化，需要继续像上更新
3.parent的平衡因子更新前是2 / -2， 说明parent平衡因子之前是 1 / -1， 插入节点在高的子树那边， 进一步加剧了parent所在子树的不平衡， 违反了AVL树的规则，需要进行旋转出处理。
3.1AVL树的旋转
3.1.1左单旋
新节点插入较高右子树的右侧，进行左单旋：
a, b, c 子树的高度均为h：
插入节点后：
a和b子树高度依旧为h， c子树变为了h + 1， 30节点的平衡因子边城了2， 60的平衡因子变为1
进行左单旋：
将b作为parent节点的右子树， 将parent节点作为右子树的左子树， 原来的右子树作为根
左单旋代码实现：
//左单旋
void RotateL(Node* parent)
{
Node* SubR = parent->_right;
Node* SubRL = SubR->_left;
parent->_right = SubRL;
if (SubRL)
{
SubRL->_parent = parent;
}
Node* parentP = parent->_parent;
SubR->_left = parent;
parent->_parent = SubR;
if (parentP == nullptr)
{
_root = SubR;
SubR->_parent = nullptr;
}
else
{
if (parentP->_left == parent)
{
parentP->_left = SubR;
SubR->_parent = parentP;
}
else
{
parentP->_right = SubR;
SubR->_parent = parentP;
}
}
//更新平衡因子
SubR->_bf = parent->_bf = 0;
}
3.1.2右单旋
新节点插入较高左子树的左边：进行右单旋
插入前a， b， c子树高度均为h：
插入后a子树高度变为h + 1：
parent 的平衡因子变为了-2左子树不平衡，需要右单旋处理：
将subLR变为parent的左子树， parent变为subL的右子树，subL变为根节点
右单旋代码实现：
//右单旋
void RotateR(Node* parent)
{
Node* SubL = parent->_left;
Node* SubLR = SubL->_right;
parent->_left = SubLR;
if (SubLR)
SubLR->_parent = parent;
Node* parentP = parent->_parent;
SubL->_right = parent;
parent->_parent = SubL;
if (parentP == nullptr)
{
_root = SubL;
SubL->_parent = nullptr;
}
else
{
if (parentP->_left == parent)
{
parentP->_left = SubL;
SubL->_parent = parentP;
}
else
{
parentP->_right = SubL;
SubL->_parent = parentP;
}
}
//更新平衡因子
SubL->_bf = parent->_bf = 0;
}
3.1.3左右双旋
新节点插入较高左子树的右侧：先进行左单旋再进行右单旋
插入之前：
插入节点后：
先对SubL进行一个左单旋：
然后对parent进行右单旋：
这样一来而二叉搜索树就恢复平衡了， 进行旋转之后我们需要对平衡因子进行更新。
先保存刚插入节点后的SubLR节点的平衡因子， 如果SubLR的平衡因子为-1那么就是插入在b下面， 平衡因子更新：parent->bf = 1；
如果SubLR的平衡因子为1那么就是插入在c下面， 平衡因子更新：SubL->bf = -1；
左右双旋代码实现：
//左右双旋
void RotateLR(Node* parent)
{
Node* SubL = parent->_left;
Node* SubLR = SubL->_right;
RotateL(SubL);
RotateR(parent);
//更新平衡因子
int bf = SubLR->_bf;
if (bf == 0)
{
SubL->_bf = 0;
SubLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
SubL->_bf = -1;
SubLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1)
{
SubL->_bf = 0;
SubLR->_bf = 0;
parent->_bf = 1;
}
else
{
assert(false);
}
}
3.1.4右左双旋
新节点插入较高右子树的左侧， 先右单旋再进行左单旋。
插入节点前：
插入节点后：
parent节点失衡， 先对SubR进行右单旋：
然后对parent进行左单旋：
这样二叉搜索树就恢复平衡了， 然后对平衡因子进行更新， 插入节点后先对SubRL的平衡因子进行保存，如果SubRL的平衡因子为1也就是插入到c子树上 ， 那么parent->bf = -1， 如果SubRL的平衡因子为-1， 也就是插入到b子树上，parent->bf = 0, SubR->bf = 1
右左双旋代码实现：
//右左双旋
void RotateRL(Node* parent)
{
Node* SubR = parent->_right;
Node* SubRL = SubR->_left;
RotateR(SubR);
RotateL(parent);
//更新平衡因子
int bf = SubRL->_bf;
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);
}
}
3.1.5旋转总结
如果parent->bf == 2 / -2时，进行一下情况的旋转：
- parent->bf == 2, 说明parent的右子树高， 设parent的右子树的根为SubR
- 当SubR->bf == 1时，执行左单旋
- 当SubR->bf == -1时， 执行右左双旋
- paren->bf == -2, 说名parent的左子树高， 设parent左子树的根为SubL
- 当SubL->bf == -1时， 执行右单旋
- 当SubL->bf == 1时， 执行左右双旋
旋转完成后原parent为根的子树高度降低，已经达到平衡，不需要再向上更新。
3.2插入操作的代码实现：
代码实现：
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
//如果是个空树就将新节点作为根节点
_root = new Node(kv);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(kv);
if (parent->_kv.first > kv.first)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
cur->_parent = parent;
//更新平衡因子
while (parent)
{
if (cur == parent->_left)
parent->_bf--;
else
parent->_bf++;
if (parent->_bf == 0)
break;
else if (parent->_bf == 1 || parent->_bf == -1)
{
//继续向上更新
cur = parent;
parent = cur->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
//二叉搜索树不平衡，需要旋转处理
if (parent->_bf == 2 && cur->_bf == 1)
{
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == -1)
{
RotateR(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
}
break;
}
else
{
assert(false);
}
}
return true;
}
四、AVL树相关接口的实现
查找函数实现：
//查找函数
Node* Find(const K& key)
{
if (_root == nullptr)
return nullptr;
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;
}
void _inorder(Node* root)
{
if (root == nullptr)
{
return;
}
_inorder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_inorder(root->_right);
}
有效节点个数：
//有效节点个数
int Size()
{
_Size(_root);
}
int _Size(Node* root)
{
return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
}
平衡二叉树高度：
//平衡二叉树高度
int Height()
{
_Height(_root);
}
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树的验证
AVL树是在二叉搜索树的基础上增加了平衡因子产生的， 因此验证AVL树可以分以下两步：
1.验证二叉搜索树
如果中序遍历一遍可以得到一个有序的序列，就说明是一个二叉搜索树。
2.验证平衡树
- 每个节点子树的高度差的绝对值不超过1
- 节点的平衡因子是否正确
验证代码实现：
void TestAVLTree()
{
AVLTree<int, int> t;
int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
for (auto e : a)
{
t.Insert({ e, e });
}
t.Inorder();
cout << t._IsBalanceTree() << endl;
}
//中序遍历
void Inorder()
{
_inorder(_root);
cout << endl;
}
//判断是否是平衡二叉树
bool _IsBalanceTree()
{
return _IsBalanceTree(_root);
}
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;
}
bool _IsBalanceTree(Node* root)
{
// 空树也是AVL树
if (nullptr == root) return true;
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;//计算高度差
if (diff != root->_bf || (diff > 1 || diff < -1))
return false;
return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}
结语： AVL树是一个能保证绝对平衡的二叉搜索树， 这样能过保证查询时的高效率， 时间复杂度为O(logN)， 但是如果对AVL树进行一些插入修改的时候性能可能会比较差，比如插入大量数据，这样会导致旋转次数过多，时间效率变差。因此AVL树对于这个结构经常进行修改的场景不太适合， 但是如果是在对有序数据进行高效查询的场景可以考虑使用AVL树来实现，这篇博客到这里就结束了， 希望大家能通过这篇博客对AVL树有所了解。
扫一扫
916
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
