目录
1. AVL树简介
AVL树是最早发明的自平衡二叉搜索树之一
平衡因子(Balance Factor)：某结点的左右子树的高度差
AVL树的特点:
每个节点的平衡因子只可能是 1、0、-1（绝对值 ≤ 1，如果超过 1，称之为“失衡”）
每个节点的左右子树高度差不超过 1
搜索、添加、删除的时间复杂度是 O(logn)
AVL树中子树失衡后, 恢复平衡,该子树的高度前后保持一致
2. AVL树添加节点
AVL树失衡情况分析:
BF: Balance Factor(该节点的平衡因子)
H: Height(节点高度)
注意: 下面在分析模型时表述旋转时是以p为中心旋转, 但在旋转方法中传入的旋转节点是g, 因为g节点可以同时兼容上层节点引用和下层节点引用
原始子树1:
添加节点n
添加节点情况1(平衡):
添加在节点n之后, 该子树仍然处于平衡状态
添加节点情况2.1 (LL):
新添加节点为节点p的左节点, 而p也为节点g的左节点;
在添加节点n之后, 子树失衡; 从节点g开始失衡, 而新添加节点作为g的Left的Left节点, 所以在旋转时可以使用 LL-右旋
LL-右旋转
添加节点情况2.2 (LL):
上面为添加n节点导致g节点失衡, 也有可能是n的左子树中添加节点导致失衡
说明: T0,T1,T2,T3 为n,p,g节点子树; 如果在n的平衡因子为0, p的平衡因子为0, g的平衡因子为1的情况下, 在n的左子树中增加一个节点, 使得n的平衡因子变为1, 则g节点将出现失衡且平衡因子变为2; 可以采用LL-右旋
节点变更操作:
- g.left = p.right
- p.right = g
- 让p成为这棵子树的根节点
- 仍然是一棵二叉搜索树：T0 < n < T1 < p < T2 < g < T3
- 整棵树都达到平衡
注意维护的内容:
- T2、p、g 的 parent 属性
- 先后更新 g、p 的高度
添加节点情况3.1 (LR):
新添加节点为节点p的右节点, 而p为节点g的左节点;
在添加节点n之后, 子树失衡; 从节点g开始失衡, 而新添加节点作为g的Left的Right节点, 所以在旋转时可以使用 LR-RR左旋, LL右旋
RR-左旋:
LL-右旋:
添加节点情况3.2 (LR):
上面为添加n节点导致g节点失衡, 也有可能是n的右子树中添加节点导致失衡
说明: T0,T1,T2,T3 为n,p,g节点子树; 如果在n的平衡因子为0, p的平衡因子为0, g的平衡因子为1的情况下, 在n的左子树中增加一个节点, 使得n的平衡因子变为-1, 则g节点将出现失衡且平衡因子变为2; 可以采用LR-RR左旋, LL右旋
原始子树2:
添加节点
添加节点情况1(平衡):
添加节点n后, 子树仍然平衡
添加节点情况2.1(RR):
新添加节点为节点p的右节点, 而p也为节点p的右节点;
在添加节点n之后, 子树失衡; 从节点g开始失衡, 而新添加节点作为g的Right的Right节点, 所以在旋转时可以使用RR左旋
RR-左旋
添加节点情况2.2(RR):
上面为添加n节点导致g节点失衡, 也有可能是n的右子树中添加节点导致失衡
RR-左旋
说明: T0,T1,T2,T3 为n,p,g节点子树; 如果在n的平衡因子为0, p的平衡因子为0, g的平衡因子为-1的情况下, 在n的右子树中增加一个节点, 使得n的平衡因子变为-1, 则g节点将出现失衡且平衡因子变为-2; 可以采用RR-左旋
节点变更操作:
- g.right = p.left
- p.left = g
- 让p成为这棵子树的根节点
- 仍然是一棵二叉搜索树：T0 < g < T1 < p < T2 < n < T3
- 整棵树都达到平衡
注意维护的内容:
- T1、p、g 的 parent 属性
- 先后更新 g、p 的高度
添加节点情况3.1(RL):
新添加节点为节点p的左节点, 而p为节点p的右节点;
在添加节点n之后, 子树失衡; 从节点g开始失衡, 而新添加节点作为g的Right的Left节点, 所以在旋转时可以使用LR-LL右旋,RR左旋
LL-右旋
RR-左旋
添加节点情况3.2(RL):
上面为添加n节点导致g节点失衡, 也有可能是n的左子树中添加节点导致失衡
LL-右旋
RR-左旋
说明: T0,T1,T2,T3 为n,p,g节点子树; 如果在n的平衡因子为0, p的平衡因子为0, g的平衡因子为-1的情况下, 在n的左子树中增加一个节点, 使得n的平衡因子变为1, 则g节点将出现失衡且平衡因子变为-2; 可以采用LR-LL右旋,RR左旋
原始子树3
此种情况, 在任何位置插入一个节点, 该子树都将保持平衡
LL-右旋, RR-左旋代码示例:
/**
* 新增节点后的操作(更新高度或者恢复平衡)
*/
@Override
protected void afterAdd(Node<E> node) {
while ((node = node.parent) != null) {
if (isBalanced(node)) {
// 更新高度
updateHeight(node);
} else {
// 恢复平衡
rebalance2(node);
// 整棵树恢复平衡
break;
}
}
}
/**
* 恢复平衡
* @param grand 高度最低的那个不平衡节点
*/
@SuppressWarnings("unused")
private void rebalance2(Node<E> grand) {
Node<E> parent = ((AVLNode<E>)grand).tallerChild();
Node<E> node = ((AVLNode<E>)parent).tallerChild(); //node节点为新添加的节点
if (parent.isLeftChild()) { // L
if (node.isLeftChild()) { // LL
rotateRight(grand);
} else { // LR
rotateLeft(parent);
rotateRight(grand);
}
} else { // R
if (node.isLeftChild()) { // RL
rotateRight(parent);
rotateLeft(grand);
} else { // RR
rotateLeft(grand);
}
}
}
/**
* 左旋
* @param grand 高度最低的那个不平衡节点
*/
private void rotateLeft(Node<E> grand) {
Node<E> parent = grand.right;
Node<E> child = parent.left;
grand.right = child;
parent.left = grand;
afterRotate(grand, parent, child);
}
/**
* 右旋
* @param grand 高度最低的那个不平衡节点
*/
private void rotateRight(Node<E> grand) {
Node<E> parent = grand.left;
Node<E> child = parent.right;
grand.left = child;
parent.right = grand;
afterRotate(grand, parent, child);
}
private void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
// 让parent称为子树的根节点
parent.parent = grand.parent;
if (grand.isLeftChild()) {
grand.parent.left = parent;
} else if (grand.isRightChild()) {
grand.parent.right = parent;
} else { // grand是root节点
root = parent;
}
// 更新child的parent
if (child != null) {
child.parent = grand;
}
// 更新grand的parent
grand.parent = parent;
// 更新高度
updateHeight(grand);
updateHeight(parent);
}统一所有旋转操作
根据四种旋转平衡初始与结果情况可以看出, 在进行不同的旋转操作后, 所有子树的排列保持一致, 其中, 节点a与节点g未发生变化,所以可以统一四种旋转操作....
/**
* 恢复平衡
* @param grand 高度最低的那个不平衡节点
*/
private void rebalance(Node<E> grand) {
Node<E> parent = ((AVLNode<E>)grand).tallerChild();
Node<E> node = ((AVLNode<E>)parent).tallerChild();
if (parent.isLeftChild()) { // L
if (node.isLeftChild()) { // LL
rotate(grand, node, node.right, parent, parent.right, grand);
} else { // LR
rotate(grand, parent, node.left, node, node.right, grand);
}
} else { // R
if (node.isLeftChild()) { // RL
rotate(grand, grand, node.left, node, node.right, parent);
} else { // RR
rotate(grand, grand, parent.left, parent, node.left, node);
}
}
}
private void rotate(
Node<E> r, // 子树的根节点
Node<E> b, Node<E> c,
Node<E> d,
Node<E> e, Node<E> f) {
// 让d成为这棵子树的根节点
d.parent = r.parent;
if (r.isLeftChild()) {
r.parent.left = d;
} else if (r.isRightChild()) {
r.parent.right = d;
} else {
root = d;
}
//b-c
b.right = c;
if (c != null) {
c.parent = b;
}
updateHeight(b);
// e-f
f.left = e;
if (e != null) {
e.parent = f;
}
updateHeight(f);
// b-d-f
d.left = b;
d.right = f;
b.parent = d;
f.parent = d;
updateHeight(d);
}3. AVL树删除节点
删除导致的失衡:
示例：删除子树中的 16
可能会导致父节点或祖先节点失衡(只有1个节点会失衡)，其他节点，都不可能失衡
LL – 右旋转
如果绿色节点不存在，更高层的祖先节点可能也会失衡，需要再次恢复平衡，然后又可能导致更高层的祖先节点失衡...
极端情况下，所有祖先节点都需要进行恢复平衡的操作，共 O(logn) 次调整
RR – 左旋转
LR – RR左旋转，LL右旋转
RL – LL右旋转，RR左旋转
删除节点后恢复平衡代码示例:
//node为真正删除的节点(因为删除度为2的节点时, 真正删除的节点时该节点的前驱节点或者后继节点)
protected void afterRemove(Node<E> node) {
while ((node = node.parent) != null) {
if (isBalanced(node)) {
// 更新高度
updateHeight(node);
} else {
// 恢复平衡
rebalance(node);
}
}
}复杂度分析
添加
可能会导致所有祖先节点都失衡
只要让高度最低的失衡节点恢复平衡，整棵树就恢复平衡【仅需 O(1) 次调整】
删除
可能会导致父节点或祖先节点失衡（只有1个节点会失衡）
恢复平衡后，可能会导致更高层的祖先节点失衡【最多需要 O(logn) 次调整】
平均时间复杂度
搜索：O(logn)
添加：O(logn)，仅需 O(1) 次的旋转操作
删除：O(logn)，最多需要 O(logn) 次的旋转操作
参考资料: 小码哥教育<<恋上数据结构与算法>>
扫一扫
1884
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
