AVL树【C++】
文章目录
- AVL树结点的定义
- Insert
-
- 左单旋
- 右单旋
- 右左双旋
- 左右双旋
- AVL树的验证
- AVL树的性能
- 完整代码
AVL树结点的定义
AVL树中的结点定义为三叉链结构，并在每个结点当中引入平衡因子（右子树高度-左子树高度）
template<class K ,class V>
struct AVLTreeNode
{
//三叉链
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
// 存储键值对
pair<K, V> _kv;
//平衡因子
int _bf;
AVLTreeNode( const pair<K,V> kv)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_kv(kv)
,_bf(0) //一开始左右子树为空树，平衡因子为0
{
}
};
Insert
bool Insert(const pair<K,V> kv)
{
//1、找到待插入位置
//空树
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
//不是空树
Node* parent = nullptr;
Node* cur = _root;
while (cur!= nullptr)
{
//待插入结点的key值 < 当前结点的key值
if (cur->_kv.first > kv.first)
{
//往左子树找
parent = cur;
cur = cur->_left;
}
// 待插入结点的key值 > 当前结点的key值
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->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
//更新平衡因子,如果出现不平衡，就进行旋转
while (parent !=nullptr) //最坏更新到根节点
{
//parent的左子树增高
if (cur == parent->_left)
{
parent->_bf--;
}
else //cur == _parent->_right
//parent的右子树增高
{
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)
{
RotateL(parent);
break;
}
//右单旋
else if (parent->_bf == -2 && cur->_bf == -1)
{
RotateR(parent);
break;
}
//右左单旋
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
break;
}
//左右单旋
if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
break;
}
}
else
{
assert(false);
}
}
return true;
}
1、找到待插入位置。
待插入结点的key值<当前结点, 就插入到该结点的左子树。
待插入结点的key值>当前结点, 就插入到该结点的右子树。
待插入结点的key值==当前结点的key值 ,就插入失败。
2、找到待插入位置后，将待插入结点插入到树中。
3、更新平衡因子，如果出现不平衡，则需要进行旋转
平衡因子的更新：
一个结点的平衡因子是否需要更新，是看该结点的左右子树的高度有没有发生变化，因此插入一个结点后，该结点的祖先结点的平衡因子可能需要更新。
插入结点后需要倒着往上更新平衡因子：
1、新增结点在parent的右边，parent的平衡因子+ +
2、新增结点在parent的左边，parent的平衡因子− −
每更新完一个结点的平衡因子后：有以下几种情况需要注意
更新后parent平衡因子== 1or-1，说明parent所在的子树的高度变化，会再影响祖先，需要继续沿着到root的路径往上更新
更新后parent平衡因子==0，说明parent所在的子树的高度不变，不会再影响祖先，不用再继续沿着到根节点的路径往上更新
更新后parent平衡因子==2 or -2，说明parent所在的子树的高度变化且不平衡，对parent所在子树进行旋转，让他平衡
最坏情况下，更新平衡因子会一路更新到根结点。例如：
插入结点后需要倒着往上进行平衡因子的更新，所以我们将AVL树结点的结构设置为了三叉链结构，这样可以通过父指针找到其父结点，进而对其平衡因子进行更新。
cur(插入结点),parent(cur的父节点)
结论：当parent的平衡因子为-2/2时，cur的平衡因子必定是-1/1而不会是0
左单旋
1、让subR的左子树作为parent的右子树。
subR的左子树中结点的值 > parent的值，因此可以作为parent的右子树。
2、让parent作为subR的左子树。
parent结点的值和parent的左子树中结点的值 < subR的值，因此可以作为subR的左子树。
3、让subR作为整个子树的根。
4、更新平衡因子。
经过左单旋后，树的高度变为插入之前了，即树的高度没有发生变化，所以左单旋后无需继续往上更新平衡因子。
分析h可能的取值：
插入之前：a, b ,c是符合AVL规则的子树
当h（树的高度）为0时
当h（树的高度）为1时
当h（树的高度）为2时，a,b就是x,y,z中任意一种类型 ，c一定是z的类型
为什么c一定是z的类型？
如果c是y类型 ，新插入节点在左边可能不需要旋转
举几个实例：
//左单旋
void RotateL(Node * parent )
{
//保持搜索树
//变成平衡树且降低树的高度
Node* cur = parent->_right;
Node* curleft = cur->_left;
parent->_right = curleft;
if (curleft!=nullptr)
{
curleft->_parent = parent;
}
cur->_left = parent;
Node* ppnode = parent->_parent;
parent->_parent = cur;
//如果parent不是一个子树 ，即parent就是根节点
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else//如果parent 是一个子树
{
if (ppnode->_left == parent)
{
ppnode->_left = cur;
}
else
{
ppnode->_right = cur;
}
cur->_parent = ppnode;
}
//修改平衡因子
parent->_bf = cur->_bf = 0;
}
右单旋
模型步骤：
1、让subL的右子树作为parent的左子树。
subL的右子树当中结点的值 < parent的值，因此可以作为parent的左子树。
2、让parent作为subL的右子树。
parent及其右子树当中结点的值 > subL的值，因此可以作为subL的右子树。
3、让subL作为整个子树的根。
4、更新平衡因子。
经过右单旋后，树的高度变为插入之前了，即树的高度没有发生变化，所以右单旋后无需继续往上更新平衡因子。
//右单旋
void RotateR(Node* parent)
{
Node * cur = parent->_left;
Node * curright = cur->_right;
//b作为60的左子树
parent->_left= curright;
if (curright !=nullptr)
{
curright->_parent = parent;
}
Node* ppnode = parent->_parent;
//60作为30的右子树
cur->_right = parent;
parent->_parent = cur;
//parent作为根节点
if (ppnode == nullptr)
{
//将cur改成根节点
_root = cur;
cur->_parent = nullptr;
}
else//parent不是根节点，作为一个子树
{
//将cur改成这个子树的根节点
if (ppnode->_left ==parent)
{
ppnode->_left = cur ;
cur->_parent = ppnode;
}
else//ppnode->_right ==parent
{
ppnode->_right = cur;
cur->_parent = ppnode;
}
}
parent->_bf = cur->_bf = 0;
}
分析h可能的取值：
插入之前：a, b ,c是符合AVL规则的子树
当h（树的高度）为0时
当h（树的高度）为1时
当h（树的高度）为2时，b,c就是x,y,z中任意一种类型 ，a一定是z的类型
右左双旋
1、插入新结点。
2、以90为旋转点进行右单旋。
3、以30为旋转点进行左单旋。
步骤：
1、以subR（90）为旋转点进行右单旋。
2、以parent（30）为旋转点进行左单旋。
3、更新平衡因子。
void RotateRL(Node* parent) //右左双旋
{
Node* cur = parent->_right;
Node* curleft = cur->_left;
//90为旋转点，进行右单旋
RotateR(parent->_right);
//30为旋转点，进行左单旋
RotateL(parent);
//更新平衡因子
int bf = curleft->_bf;
//插入节点就是60
if (bf == 0)
{
curleft->_bf = 0;
parent->_bf = 0;
cur->_bf = 0;
}
//插入节点是60的右边
else if(bf ==1)
{
curleft->_bf = 0;
parent->_bf = -1;
cur->_bf = 0;
}
//插入节点是60的左边
else if (bf==-1)
{
curleft->_bf = 0;
parent->_bf = 0;
cur->_bf = 1;
}
else
{
assert(false);
}
}
分析h可能的取值：
插入之前：a, b ,c是符合AVL规则的子树
当h（树的高度）为0时
当h（树的高度）为1时，有两种情况：
1、插入节点是60的左边
2、插入节点是60的右边
区分关键：看60的平衡因子
当h（树的高度）为2时，a, d是x,y,z中任意一颗子树
右左双旋的本质：
60的左边给30的右边
60的右边给90的左边
60成了这棵树的根
左右双旋
1、插入新结点。
2、以30为旋转点进行左单旋。
3、以90为旋转点进行右单旋。
步骤：
1、以subL为旋转点进行左单旋。
2、以parent为旋转点进行右单旋。
3、更新平衡因子。
左右双旋后，实际上就是让subLR的左子树和右子树，分别作为subL和parent的右子树和左子树，再让subL和parent分别作为subLR的左右子树，最后让subLR作为整个子树的根（结合图理解）。
三种情况会引发双旋
1、60就是新增
2、b 或者c 插入
void RotateLR(Node* parent)
{
Node* cur = parent->_left;
Node* curright = cur->_right;
//30为旋转点，进行左单旋
RotateL(cur);
//90为旋转点，进行右单旋
RotateR(parent);
//更新平衡因子
int bf = curright->_bf;
//插入节点就是60
if (bf == 0)
{
cur->_bf = curright->_bf = parent->_bf = 0;
}
//插入节点是60的左边
else if (bf == -1)
{
curright->_bf = parent->_bf = 0;
cur->_bf = 1;
}
//插入节点是60的右边
else if (bf == 1)
{
cur->_bf = curright->_bf = 0;
parent->_bf = 1;
}
else
{
assert(false);
}
}
AVL树的验证
满足AVL，就满足 右子树-左子树的高度差 < 2 ,在该过程中我们可以检查每个结点当中平衡因子是否正确。
int Height(Node *root)
{
if (root == nullptr)
{
return 0;
}
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
if (leftHeight > rightHeight)
{
return leftHeight + 1;
}
else//(leftHeight <= rightHeight)
{
return rightHeight + 1;
}
}
bool IsBalance()
{
return _IsBalance(_root);
}
bool _IsBalance(Node* root)
{
if (root == nullptr)
{
return true;
}
//左右子树高度差 < 2
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
if ( (rightHeight - leftHeight) != root->_bf)
{
cout << "平衡因子异常:" << root->_kv.first << "->" << root->_bf << endl;
return false;
}
else if (abs(rightHeight - leftHeight) < 2 && _IsBalance(root->_left) && _IsBalance(root->_right) )
{
return true;
}
else
{
return false;
}
}
AVL树的性能
AVL树是一棵绝对平衡的二叉搜索树，其要求每个结点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即logN。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。
因此，如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的（即不会改变），可以考虑AVL树，但当一个结构经常需要被修改时，AVL树就不太适合了。
完整代码
#include测试代码
#include"AVLTree.h"
void Test1()
{
AVLTree<int, int> t;
int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
for (auto e : a)
{
/*手动断点*/
if (e == 7)
{
int x = 10;//仅仅是为了打断点，空语句不能打断点
}
t.Insert(make_pair(e, e));
//cout << "Insert ："<";
//
//cout<< t.IsBalance();
//cout << endl;
cout << "Insert:" << e << "->" << t.IsBalance() << endl;
}
}
void Test2() //测试左单旋函数
{
AVLTree<int, int> t;
int a[] = { 30,60,90 };
for (auto e : a)
{
t.Insert( make_pair(e,e) ) ;
cout << "Insert:" << e << "->" << t.IsBalance() << endl;
}
}
int main()
{
Test1();
//Test2();
return 0;
}