目录
1. 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树整体结点数量和分布和完全二叉树类似，高度可以控制在 ，那么增删查改的效率也可以控制在 ，相比二叉搜索树有了本质的提升。
- 完全二叉树,如果高度是h,满的情况下就是2^h-1,用等比数列公式就可以算出,2^(h-1) = N,如果是满二叉树的情况下,h = log以2为底的N+1。
- 如果是完全二叉树,完全二叉树也是特殊的满二叉树,假设最后一层只有一个结点,就是结点数量最少的高度为h的满二叉树,最后一层只有一个结点,前面的我们就可以当做2^(h-1)层 - 1,就是前面h-1层的数量,在加最后一层只有一个,等于N,h = log以2为底的N + 1。
- 如果是满二叉树的情况下就是log以2为底的n+1次方,结点最少的情况下是log以2为底的n次方+1,所有我们可以看到最后两层缺的结点对我们的结构整体影响是不大的,我们都可以认为是log2n这个量级,AVL树最后两层缺一些结点,但是我们还是可以认为高度还是logn。
当在14的左边插入13后,会导致以10为根结点的树不是一颗AVL树。
2. AVL树的实现
2.1 AVL树的结构
#include <iostream>
using namespace std;
namespace Aurora
{
template<class K,class V>
struct AVLTreeNode
{
// 需要parent指针，后续更新平衡因⼦可以看到
pair<K,V> _kv;
AVLTreeNode<K,V>* _left;
AVLTreeNode<K,V>* _right;
AVLTreeNode<K,V>* _parent;
int _bf;// balance factor
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.2 AVL树的插入
2.2.1 AVL树插入一个值的大概过程
- 插入一个值按二叉搜索树规则进行插入。
- 新增结点以后,只会影响祖先结点的高度,也就是可能会影响部分祖先结点的平衡因子,所有更新从新增结点->根结点路径上的平衡因子,实际中最坏情况下要更新到根,有些情况更新到中间就可以停止了。
- 更新平衡因为过程中出现不平衡,对不平衡树旋转,旋转后本质调平衡的同时,本质降低了子树的高度,不会影响上一层,所以插入结束。
2.2.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也停止了。
2.2.3 插入结点及更新平衡因子的代码实现
#include <iostream>
using namespace std;
namespace Aurora
{
template<class K,class V>
struct AVLTreeNode
{
// 需要parent指针，后续更新平衡因⼦可以看到
pair<K,V> _kv;
AVLTreeNode<K,V>* _left;
AVLTreeNode<K,V>* _right;
AVLTreeNode<K,V>* _parent;
int _bf;// balance factor
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* cur = _root;
Node* parent = nullptr
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 if(cur->_kv.first == kv.first)
{
return false;
}
}
cur = new Node(kv);
if(parent->_kv.first > kv.first)
{
parent->_left = cur;
}
else if(parent->_kv.first < kv.first)
{
parent->_right = cur;
}
//当前结点跟父结点链接在一起
cur->_parent = parent;
//更新平衡因子
while(parent)
{
if(parent->_left == cur)
{
parent->_kv--;
}
else if(parent->_right == cur)
{
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)
{
//旋转
break;
}
else
{
assert(false);
}
}
return true;
}
private:
Node* _root = nullptr;
};
}2.3 旋转
2.3.1 旋转的原则
- 保持搜索树的规则。
- 让旋转的树从不满足变平衡,其次降低旋转树的高度。
旋转总共分为四种,左单旋/右单旋/左右双旋/右左双旋。
2.3.2 右单旋
- 本图1展示的是10为根的树,有a/b/c抽象为三棵高度为h的子树(h>=0),a/b/c均符合AVL树的要求。10可能是整棵树的根,也可能是一个整棵树中局部的子树的根。这里a/b/c是高度为h的子树,是一种概括抽象表示,他代表了所有右单旋的场景,实际右单旋形态有很多种,具体图2/图3/图4/图5进行了详细描述。
- 在a子树中插入一个新结点,导致a子树的高度从h变成h+1,不断向上更新平衡因子,导致10的平衡因子从-1变成-2,10为根的树左右高度差超过1,违反平衡规则。10为根的树左边太高了,需要往右边旋转,控制两棵树的平衡。
- 旋转核心步骤,因为5 < b子树的值 < 10,将b变成10的左子树,10变成5的右子树,5变成这棵树新的根,符合搜索树的规则,控制了平衡,同时这棵的高度恢复到了插入之前的h+2,符合旋转原则。如果插入之前10整棵树的⼀个局部子树,旋转后不会再影响上⼀层,插入结束了。
2.3.3 右单旋代码实现
//右单旋
void RotateR(Node* parent)
{
//找到要调整的节点
Node* subL = parent->_left;
Node* subLR = subL->_right;
//修改指向
parent->_left = subLR;
subL->_right = parent;
//保存parent的父节点
Node* pphead = parent->_parent;
//修改节点中_parent的指向
if (subLR)
subLR->_parent = parent;
parent->_parent = subL;
//更新根节点的父节点
//if(pphead == nullptr)
if (parent == _root)
{
//直接更新_root节点
_root = subL;
//将根节点的_parent的节点置为空
subL->_parent = nullptr;
}
else
{
if (pphead->_left == parent)
{
pphead->_left = subL;
}
else if (pphead->_right == parent)
{
pphead->_right = subL;
}
//更新根节点的_parent
subL->_parent = pphead;
}
//更新平衡因子
parent->_bf = subL->_bf = 0;
}2.3.4 左单旋
- 本图6展示的是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整棵树的一个局部子树,旋转后不会影响上一层,插入结束。
2.3.5 左单旋代码实现
//左单旋
void RotateL(Node* parent)
{
//确定要调整的节点
Node* subR = parent->_right;
Node* subRL = subR->_left;
//改变节点关系
parent->_right = subRL;
subR->_left = parent;
//保存parent的父节点
Node* pphead = parent->_parent;
//改变每个节点的_parent
if (subRL)
subRL->_parent = parent;
parent->_parent = subR;
//if(pphead == nullptr)
if (parent == _root)
{
//更新根节点
_root = subR;
//更新根节点的父节点
subR->_parent = nullptr;
}
else
{
//将根节点和根节点的父节点链接
if (pphead->_left == parent)
{
pphead->_left = subR;
}
else if (pphead->_right == parent)
{
pphead->_right = subR;
}
//更新根节点的_parent
subR->_parent = pphead;
}
//更新平衡因子
parent->_bf = subR->_bf = 0;
}2.3.6 左右双旋
通过图7和图8可以看到,左边高时m,如果插入位置不是在a子树,而是插入在b子树,b子树高度从h变成h+1,引发旋转,右边单旋无法解决问题,右单旋后,我们的树依旧不平衡。右单旋解决的纯粹的左边高,但是插入在b子树中,10为根的子树不再是单纯的左边高,对于10是左边高,但对于5是右边高,需要用两次旋转才能解决,以5为旋转点进行一个左单旋,以10为旋转点进行一个右单旋,这棵树就平衡了。
- 图7和图8分别为左右双旋中h==0和h==1具体场景分析,下面我们将a/b/c子树抽象为高度为h的AVL子树进行分析,另外我们需要把b子树的细节进一步展开为8和左子树高度为h-1的e和f子树,因为我们要对b的父亲5为旋转点进行左单旋,左单旋需要动b树中的左子树。b子树中新增节点的位置不同,平衡因子更新的细节也不同,通过观察8的平衡因子不同,这里我们要分三个场景讨论。
- 场景1:h >= 1时,新增结点插入在e子树,e子树高度从h-1并为h并不断更新8->5->10平衡因子,引发旋转,其中8的平衡因子为-1,旋转后8和5平衡因子为0,10平衡因子为1。
- 场景2:h>=1时,新增节点插入在f子树,f子树高度从h-1变为h并不断更新8->5->10平衡因子,引发旋转,其中8的平衡因子为1,旋转后8和10平衡因子都为0,5平衡因子为-1。
- 场景3:h==0时,a/b/c都是空树,b自己就是一个新增节点,不断更新5->10平衡因子,引发旋转,其中8的平衡因子为0,旋转后8和10和5平衡因子均为0。
2.3.7 左右双旋代码实现
//左右双旋
void RotateLR(Node* parent)
{
//保存要调整的节点,方便更新平衡因子
Node* subL = parent->_left;
Node* subLR = subL->_right;
//记录subLR节点的平衡因子
int bf = subLR->_bf;
//首先对subL进行左单旋
RotateL(parent->_left);
//再对parent进行右旋转
RotateR(parent);
//更新平衡因子
if (bf == -1)
{
subLR->_bf = 0;
subL->_bf = 0;
parent = 1;
}
else if (bf == 1)
{
subLR->_bf = 0;
subL->_bf = -1;
parent = 0;
}
else if (bf == 0)
{
subLR->_bf = 0;
subL->_bf = 0;
parent = 0;
}
else
{
assert(false);
}
}2.3.8 右左双旋
- 跟左右双旋类似,下面我们将a/b/c子树抽象为高度h的AVL子树进行分析,另外我们需要把b子树的细节进一步展开为12和左子树高度为h-1的e和f子树,因为我们要对b的父亲15为旋转点进行右单旋,右单旋需要动b树中的右子树,b子树中新增节点的位置不同,平衡因子更新的细节也不同,通过观察12的平衡因子不同,这里我们要分三个场景讨论。
- 场景1:h>=1时,新增节点插入再e子树,e子树高度从h-1变为h并不断更新12->15->10平衡因子,引发旋转,其中12的平衡因子为-1,旋转后10和12平衡因子为0,15平衡因子为1。
- 场景2:h>=1时,新增节点插入再f子树,f子树高度从h-1变为h并不断更新12->15->10平衡因子,引发旋转,其中12的平衡因子为1,旋转后14和12的平衡因子为0,10平衡因子为-1。
- 场景3:h==0时,a/b/c都是空树,b自己就是一个新增节点,不断更新15->10平衡因子,引发旋转,其中12的平衡因子为0,旋转后10和12和15的平衡因子均为0。
2.3.9 右左双旋代码实现
//右左双旋
void RotateRL(Node* parent)
{
//保留节点,方便更新平衡因子
Node* subR = parent->_right;
Node* subRL = subR->_left;
//保留subRL中的平衡因子
int bf = subRL->_bf;
//对subR进行右单旋
RotateR(parent->_right);
//对parent进行左单旋
RotateL(parent);
//更新平衡因子
if (bf == 1)
{
parent->_bf = -1;
subR->_bf = 0;
subRL->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 0;
subR->_bf = 1;
subRL->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subR->_bf = 0;
subRL->_bf = 0;
}
else
{
assert(false);
}
}2.4 AVL树的查找
用二叉搜索树逻辑实现即可,搜索效率为O(logN)
//AVL树的查找
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first > key)
{
cur = cur->_left;
}
else if (cur->_kv.first < key)
{
cur = cur->_right;
}
else if (cur->_kv.first == key)
{
return cur;
}
}
return nullptr;
}2.5 AVL树的中序遍历
类里面用递归的话,外面最好封装一层
//AVL树的遍历
void _InOrder(Node* root)
{
if (root == nullptr) return;
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}2.6 AVL树平衡检测
我们实现的AVL树是否合格,我们不应该去检查平衡因子,平衡因子是随着值的插入而改变的,那如果平衡因子也是错误的呢? 我们应该通过检查左右子树高度差的程序进行反向验证,同时检查一下节点的平衡因子更新是否出现了问题。
//检查该树是否是AVL树
bool _IsBalanceTree(Node* root)
{
//空树也是AVL树
if (root == nullptr) return true;
//计算右子树的高度
int rightHight = _Height(root->_right);
//计算左子树的高度
int leftHight = _Height(root->_left);
//右子树的高度减去左子树的高度,算出高度差
int diff = rightHight - leftHight;
//判断高度是否合理
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
if (root->_bf != diff)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalanceTree(root->_left) && _IsBalanceTree(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;
}2.7 求节点个数
//_Size
int _Size(Node* root)
{
if (root == nullptr) return 0;
return 1 + _Size(root->_left) + _Size(root->_right);
}2.8 测试程序
//测试代码
void TestAVLTree1()
{
Aurora::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 (const auto& e : a)
{
if (e == 6)
{
int x = 0;
}
t.Insert({ e,e });
}
//遍历
t.InOrder();
cout << t.IsBalanceTree() << endl;
}
//插入一堆随机值,测试平衡,顺便测试高度,性能等
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 begin2 = clock();
Aurora::AVLTree<int, int> t;
for (const auto& e : v)
{
t.Insert(make_pair(e, e));
}
size_t end2 = clock();
cout << "Insert:" << end2 - begin2 << endl;
cout << t.IsBalanceTree() << endl;
cout << "Height:" << t.Height() << endl;
cout << "Size:" << t.Size() << endl;
size_t begin1 = clock();
// 确定在的值
/*for (auto e : v)
{
t.Find(e);
}*/
// 随机值
for (size_t i = 0; i < N; i++)
{
t.Find((rand() + i));
}
size_t end1 = clock();
cout << "Find:" << end1 - begin1 << endl;
}2.9 AVL树的删除
略
https://gitee.com/Axurea/c-plus-plus/tree/master/2025_01_20_AVLTree
扫一扫
1443
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
