AVL树_avl树插入调整一次即可-CSDN博客

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);
        }
    }
}