1.AVL树
4.1.1 AVL树的概念
二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年
发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均搜索长度。
一棵AVL树或者是空树,或者是具有以下性质的二叉搜索树:
- 它的左右子树都是AVL树
- 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
如果一棵二叉搜索树是高度平衡的,它就是AVL树。如果它有n个结点,其高度可保持在 O ( l o g 2 n ) O(log_2 n) O(log2n),搜索时间复杂度O( l o g 2 n log_2 n log2n)
4.1.2 AVL树节点的定义
AVL树节点的定义:
// 节点类
template<class K,class V>
struct AVLTreeNode
{
//K _key;// 节点数据
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),
_bf(0),
_kv(kv)
{}
};
4.1.3 AVL树的插入
AVL树就是在二叉搜索树的基础上引入了平衡因子,因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步:
- 1.按照二叉搜索树的方式插入新节点
- 2.调整节点的平衡因子
插入的规则要求:
- 按照搜索树规则插入
- 更新插入节点的祖先节点的平衡因子
- a.插入父亲的左边,父亲的平衡因子–
- b.插入父亲的右边,父亲的平衡因子++
- c.更新后父亲的平衡因子 == 0,父亲所在子树高度不变,不再继续往上更新,插入结束
- d.更新后父亲的平衡因子 == 1 or -1,父亲所在子树高度变了,继续往上更新
- e.更新后父亲的平衡因子 == 2 or -2,父亲所在子树已经不平衡了,需要旋转处理
更新中不可能出现其他值,插入之前树是AVL树,平衡因子要么是1 -1 0,++ --最多就是c/d/e三种情况
插入(insert)方法
bool Insert(const pair<K,V>& kv)
1.先按照搜索树规则插入:
先判断是否为空,之后比较数据,小于节点数据则走左子树,大于走右子树,等于则错误(不能冗余)
找到插入位置,则判断左孩子还是右孩子
// 判断是否为空
if (_root == nullptr)
{
// 插入的节点就时根节点
_root = new Node(kv);
return true;
}
//1.按照搜索树规则插入
// _root不为空时,要从根节点开始向下查询
// 记录父亲节点
Node* parent = nullptr;
Node* cur = _root;
// 循环结束条件,查找到叶子节点
while (cur)
{
// kv的first小于cur的first,查找左子数
// 反之,查找右子树
if (kv.first < cur->_kv.first)
{
parent = cur;// 记录父亲节点
cur = cur->_left;
}
else if (kv.first > cur->_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;
// 更新平衡因子
// ...
- 更新插入节点的祖先节点的平衡因子
a.插入父亲的左边,父亲的平衡因子–
b.插入父亲的右边,父亲的平衡因子++
// 插入完成后
// 更新平衡因子
// 2.更新插入节点的祖先节点的平衡因子
// 由下向上更新
// 这棵树的平衡因子定义为 平衡因子 = 右子树高度 - 左子树高度
// 由下往上改平衡因子
while (parent)
{
// a.插入父亲的左边,父亲的平衡因子--
if (cur == parent->_left)
{
parent->_bf--;
}
else// b.插入父亲的右边,父亲的平衡因子++
{
parent->_bf++;
}
// 此处先省略
//...
}
c.更新后父亲的平衡因子 == 0,父亲所在子树高度不变,不再继续往上更新,插入结束
d.更新后父亲的平衡因子 == 1 or -1,父亲所在子树高度变了,继续往上更新
在上面的省略处写
// c.更新后父亲的平衡因子 == 0,父亲所在子树高度不变,不再继续往上更新,插入结束
if (parent->_bf == 0) // 1 -1 -> 0
{
// 更新完毕
break;
}
// d.更新后父亲的平衡因子 == 1 or -1,父亲所在子 树高度变了,继续往上更新
else if (parent->_bf == 1 || parent->_bf == -1) // 0 -> 1 -1
{
// 继续往上更新
// 往上更新,将父亲给cur
cur = parent;
parent = parent->_parent;
}
// e.更新后父亲的平衡因子 == 2 or -2,父亲所在子树已经不平衡了,需要旋转处理
else if (parent->_bf == -2 || parent->_bf == 2) // 1 -1 -> 2 -2
{
//...
}
e.更新后父亲的平衡因子 == 2 or -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);
}
插入方法的代码总和
bool Insert(const pair<K,V>& kv)
{
// 判断是否为空
if (_root == nullptr)
{
// 插入的节点就时根节点
_root = new Node(kv);
return true;
}
//1.按照搜索树规则插入
// _root不为空时,要从根节点开始向下查询
// 记录父亲节点
Node* parent = nullptr;
Node* cur = _root;
// 循环结束条件,查找到叶子节点
while (cur)
{
// kv的first小于cur的first,查找左子数
// 反之,查找右子树
if (kv.first < cur->_kv.first)
{
parent = cur;// 记录父亲节点
cur = cur->_left;
}
else if (kv.first > cur->_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;
// 插入完成后
// 更新平衡因子
// 2.更新插入节点的祖先节点的平衡因子
// 由下向上更新
// 这棵树的平衡因子定义为 平衡因子 = 右子树高度 - 左子树高度
// 由下往上改平衡因子
while (parent)
{
// a.插入父亲的左边,父亲的平衡因子--
if (cur == parent->_left)
{
parent->_bf--;
}
else// b.插入父亲的右边,父亲的平衡因子++
{
parent->_bf++;
}
// c.更新后父亲的平衡因子 == 0,父亲所在子树高度不变,不再继续往上更新,插入结束
if (parent->_bf == 0) // 1 -1 -> 0
{
// 更新完毕
break;
}
// d.更新后父亲的平衡因子 == 1 or -1,父亲所在子 树高度变了,继续往上更新
else if (parent->_bf == 1 || parent->_bf == -1) // 0 -> 1 -1
{
// 继续往上更新
// 往上更新,将父亲给cur
cur = parent;
parent = parent->_parent;
}
// e.更新后父亲的平衡因子 == 2 or -2,父亲所在子树已经不平衡了,需要旋转处理
else if (parent->_bf == -2 || parent->_bf == 2) // 1 -1 -> 2 -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);
}
break;
}
}
return true;
}
4.1.4 AVL树的旋转
如果在一棵原本是平衡的AVL树中插入一个新节点,可能造成不平衡,此时必须调整树的结构,使之平衡化。根据节点插入位置的不同,AVL树的旋转分为四种:
- 新节点插入较高左子树的左侧—左左:右单旋
// 旋转只有看parent的节点
// 右单旋
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
// 每个节点的父亲也要记得修改
if (subLR != nullptr)
{
subLR->_parent = parent;
}
Node* ppNode = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
// 更新平衡因子
// 注意两个关键情况:
// 1.parent为根节点
// 2.parent是第二层的节点
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
// 更新平衡因子
parent->_bf = subL->_bf = 0;
}
- 新节点插入较高右子树的右侧—右右:左单旋
// 左单旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL != nullptr)
{
subRL->_parent = parent;
}
Node* ppNode = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
// 更新平衡因子
// 注意两个关键情况:
// 1.parent为根节点
// 2.parent是第二层的节点
if (parent == _root)
{
_root = subR ;
subR->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subR;
}
else
{
ppNode->_right = subR;
}
subR->_parent = ppNode;
}
// 更新平衡因子
parent->_bf = subR->_bf = 0;
}
- 新节点插入较高左子树的右侧—左右:先左单旋再右单旋
这里面又分为三种情况:
a.60自己就是新增
b.b插入时,引发的旋转
c.c插入时,引发的旋转
// 左右单旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;// 记录一下平衡因子
// 先进行左单旋,在进行右单旋
RotateL(subL);
RotateR(parent);
//更新平衡因子三种情况
// 1.60自己就是新增
if (bf == 0)
{
subLR->_bf = 0;
subL->_bf = 0;
parent->_bf = 0;
}
// 2.60的平衡因子为-1,b插入
else if (bf == -1)
{
subLR->_bf = 0;
subL->_bf = 0;
parent->_bf = 1;
}
// 3.60的平衡因子为1,c插入
else if (bf == 1)
{
subLR->_bf = 0;
subL->_bf = -1;
parent->_bf = 0;
}
else
{
assert(false);
}
}
- 新节点插入较高右子树的左侧—右左:先右单旋再左单旋
a.60自己就是新增
b.b插入时,引发的旋转
c.c插入时,引发的旋转
// 右左单旋
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
// 记录平衡因子
int bf = subRL->_bf;
// 先右旋,在左旋
RotateR(subR);
RotateL(parent);
subRL->_bf = 0;
// 更新平衡因子三种情况
// 1.60自己就是新增
if (bf == 0)
{
subR->_bf = 0;
parent->_bf = 0;
}
// 2.60的平衡因子为-1,b插入
else if (bf == -1)
{
subR->_bf = 1;
parent->_bf = 0;
}
// 3.60的平衡因子为1,c插入
else if (bf == 1)
{
subR->_bf = 0;
parent->_bf = -1;
}
else
{
assert(false);
}
}
4.1.5 AVL树的验证
AVL树是在二叉搜索树的基础上加入了平衡性的限制,因此要验证AVL树,可以分两步:
- 验证其为二叉搜索树
如果中序遍历可得到一个有序的序列,就说明为二叉搜索树
- 验证其为平衡树
每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确
4.1.6 AVL树的删除(了解)
因为AVL树也是二叉搜索树,可按照二叉搜索树的方式将节点删除,然后再更新平衡因子,只不错与删除不同的时,删除节点后的平衡因子更新,最差情况下一直要调整到根节点的位置。
具体实现学生们可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。
// 中序输出
void InOrder()
{
_InOrder(_root);
cout << endl;
}
// 判断平衡
bool IsBalance()
{
return _IsBalance(_root);
}
//计算高度
int Height()
{
return _Height(_root);
}
// 节点数量
int Size()
{
return _Size(_root);
}
private:
// 计算节点个数基本
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;
}
return max(_Height(root->_left), _Height(root->_right)) + 1;
}
// 判断平衡基本
bool _IsBalance(Node* root)
{
if (root == nullptr)
{
return true;
}
int leftHight = _Height(root->_left);
int rightHight = _Height(root->_right);
// 不平衡
if (abs(rightHight - leftHight) >= 2)
{
return false;
}
// 顺便检查一下平衡因子是否正确
if (rightHight - leftHight != root->_bf)
{
cout << root->_kv.first << endl;
return false;
}
// 判断左子树和右子树是否平衡
return _IsBalance(root->_left)
&& _IsBalance(root->_right);
}
// 中序输出基本
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
4.1.7 AVL树的性能
AVL树是一棵绝对平衡的二叉搜索树,其要求每个节点的左右子树高度差的绝对值都不超过1,这样可以保证查询时高效的时间复杂度,即 l o g 2 ( N ) log_2 (N) log2(N)。但是如果要对AVL树做一些结构修改的操作,性能非常低下。
比如:插入时要维护其绝对平衡,旋转的次数比较多,更差的是在删除时,有可能一直要让旋转持续到根的位置。因此:如果需要一种查询高效且有序的数据结构,而且数据的个数为静态的(即不会改变),可以考虑AVL树,但一个结构经常修改,就不太适合。