第八章平衡二叉搜索树、AVL树-CFANZ编程社区

第八章平衡二叉搜索树、AVL树

二叉搜索树缺点分析

第八章平衡二叉搜索树、AVL树_数据结构

当 n 比较大时，两者的性能差异比较大
比如 n = 1000000 时，二叉搜索树的最低高度是 20，最高高度是 1000000

由此可见，

二叉搜索树添加节点时可能会导致二叉搜索树退化成链表

删除节点时也可能会导致二叉搜索树退化成链表

有没有办法防止二叉搜索树退化成链表？

让添加、删除、搜索的复杂度维持在 O(logn)？

改进二叉搜索树

平衡（Balance）

平衡：当节点数量固定时，左右子树的高度越接近，这棵二叉树就越平衡（高度越低）

第八章平衡二叉搜索树、AVL树_算法_02

理想平衡

最理想的平衡，就是像完全二叉树、满二叉树那样，高度是最小的

第八章平衡二叉搜索树、AVL树_算法_03

如何改进二叉搜索树？

首先，节点的添加、删除顺序是无法限制的，可以认为是随机的
所以，改进方案是：在节点的添加、删除操作之后，想办法让二叉搜索树恢复平衡（减小树的高度）

第八章平衡二叉搜索树、AVL树_leetcode_04

如果接着继续调整节点的位置，完全可以达到理想平衡，但是付出的代价可能会比较大

比如调整的次数会比较多，反而增加了时间复杂度

总结来说，比较合理的改进方案是：用尽量少的调整次数达到适度平衡即可
一棵达到适度平衡的二叉搜索树，可以称之为：平衡二叉搜索树

平衡二叉搜索树（Balanced Binary Search Tree）

英文简称为：BBST
经典常见的平衡二叉搜索树有：

AVL树

Windows NT 内核中广泛使用

红黑树

C++ STL（比如 map、set ）
Java 的 TreeMap、TreeSet、HashMap、HashSet
Linux 的进程调度
Ngix 的 timer 管理

一般也称它们为：自平衡的二叉搜索树（Self-balancing Binary Search Tree）

AVL树

AVL 树是最早发明的自平衡二叉搜索树之—
AVL取名于两位发明者的名字

G.M.Adelson-Velsky 和 E.M.Landis（来自苏联的科学家）

平衡因子（Balance Factor）：某结点的左右子树的高度差
AVL树的特点：

每个节点的平衡因子只可能是 1、0、-1 (绝对值 ≤ 1，如果超过 1，称之为 “失衡")
每个节点的左右子树高度差不超过1
搜索、添加、删除的时间复杂度是 O ( logn )

第八章平衡二叉搜索树、AVL树_AVL树_05

BST 对比 AVLTree

输入数据：35, 37, 34, 56, 25, 62, 57, 9, 74, 32, 94, 80, 75, 100, 16, 82

第八章平衡二叉搜索树、AVL树_AVL树_06

继承 BST

第八章平衡二叉搜索树、AVL树_平衡二叉树_07

添加节点导致的失衡

示例：往下面这棵子树中添加 13

最坏情况：可能会导致所有祖先节点都失衡
父节点、非祖先节点，都不可能失衡

第八章平衡二叉搜索树、AVL树_AVL树_08

修复平衡的操作：

LL – 右旋转（单旋）
RR – 左旋转（单旋）
LR – 先左旋，再右旋（双旋）
RL – 先右旋，再左旋（双旋）

有些教程里面：

把右旋转叫做 zig，旋转之后的状态叫做 zigged
把左旋转叫做 zag，旋转之后的状态叫做 zagged

LL – 右旋转（单旋）

有些教程里面，把右旋转叫做zig，旋转之后的状态叫做zigged

操作步骤

g.left = p.right
p.right = g
让p 成为这颗子树的根节点
旋转后仍然是一颗二叉搜索树：T0 < n < T1 < p < T2 < g < T3
整棵树都达到平衡

第八章平衡二叉搜索树、AVL树_AVL树_09

还需要注意维护的内容

T2、p、g 的parent 属性

先后更新g、p 的高度

/**
 * 右旋
 *
 * @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);
}

RR – 左旋转（单旋）

有些教程里面，把左旋转叫做zag，旋转之后的状态叫做zagged

操作步骤

g.right = p.left
p.left = g
让p 成为这颗子树的根节点
旋转后仍然是一颗二叉搜索树：T0 < g < T1 < o < T2 < n < T3
整棵树都达到平衡

第八章平衡二叉搜索树、AVL树_AVL树_10

还需要注意维护的内容

T1、p、g 的parent 属性

先后更新g、p 的高度

/**
 * 左旋
 *
 * @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);
}

LR – 先左旋，再右旋（双旋）

LR 就是先进行 左旋转 – RR、再进行 右旋转 – LL

先左旋转：p.right = n.left、n.left = p
再右旋转：g.left = n.right、n.right = g
旋转后仍然是一颗二叉搜索树：T0 < p < T1 < n < T2 < g < T3
整棵树都达到平衡

第八章平衡二叉搜索树、AVL树_数据结构_11

RL – 先右旋，再左旋（双旋）

RL 就是先进行 右旋转 – LL、再进行 左旋转 – RR

先右旋转：p.left = n.right、n.right = p
再左旋转：g.right = n.left、n.left = g
旋转后仍然是一颗二叉搜索树：T0 < g < T1 < n < T2 < p < T3
整棵树都达到平衡

第八章平衡二叉搜索树、AVL树_数据结构_12

旋转之后维护的内容

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 = parent;
    }

    //更新child的parent
    if (child != null) {
        child.parent = grand;
    }

    //更新grand的parent
    grand.parent = parent;

    //更新高度
    updateHeight(grand);
    updateHeight(parent);
}

添加之后的修复图解

输入数据：13, 14, 15, 12, 11, 17, 16, 8, 9, 1
输入13：正常
输入14：正常
输入15：13失衡，RR，左旋转

第八章平衡二叉搜索树、AVL树_数据结构_13

输入12：正常
输入11：13失衡，LL，右旋转

第八章平衡二叉搜索树、AVL树_数据结构_14

输入17：正常
输入16：15失衡，RL，先对17进行右旋转、再对15进行左旋转

第八章平衡二叉搜索树、AVL树_leetcode_15

输入8：正常
输入9：11失衡，LR，先对8进行左旋转、再对11进行右旋转

第八章平衡二叉搜索树、AVL树_leetcode_16

输入1：12失衡，LL，对12进行右旋转

第八章平衡二叉搜索树、AVL树_leetcode_17

添加之后的修复 - 代码实现

@Override
protected void afterAdd(Node<E> node) {
    while ((node = node.parent) != null) {
        if (isBalanced(node)) {
            //更新高度
            updateHeight(node);
        } else {
            //恢复平衡
            rebalance(node);
            //整棵树恢复平衡
            break;
        }
    }
}

/**
 * 恢复平衡
 *
 * @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
            rotateRight(grand); //右旋
        } else { //LR
            rotateLeft(parent); //左旋
            rotateRight(grand); //右旋
        }
    } else { //R
        if (node.isLeftChild()) { //RL
            rotateRight(parent); //右旋
            rotateLeft(grand); //左旋
        } else { //RR
            rotateLeft(grand); //左旋
        }
    }
}

统一所有的旋转操作

第八章平衡二叉搜索树、AVL树_AVL树_18

private void rotate(
        Node<E> r, //子树的根节点
        Node<E> a, Node<E> b, Node<E> c,
        Node<E> d,
        Node<E> e, Node<E> f, Node<E> g) {
    //让d成为这棵子树的根节点
    d.parent = r.parent;
    if (r.isLeftChild()) {
        r.parent.left = d;
    } else if (r.isRightChild()) {
        r.parent.right = d;
    } else {
        root = d;
    }

    // a - b - c
    b.left = a;
    if (a != null) {
        a.parent = b;
    }
    b.right = c;
    if (c != null) {
        c.parent = b;
    }
    updateHeight(b); //更新b的高度

    // e - f - g
    f.left = e;
    if (e != null) {
        e.parent = f;
    }
    f.right = g;
    if (g != null) {
        g.parent = f;
    }
    updateHeight(f); //更新f的高度

    // b - d - f
    d.left = b;
    d.right = f;
    b.parent = d;
    f.parent = d;
    updateHeight(d); //更新d的高度
}

/**
 * 统一旋转操作
 * 恢复平衡
 *
 * @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.left, node, node.right, parent, parent.right, grand, grand.right);
        } else { //LR
            rotate(grand, parent.left, parent, node.left, node, node.right, grand, grand.right);
        }
    } else { //R
        if (node.isLeftChild()) { //RL
            rotate(grand, grand.left, grand, node.left, node, node.right, parent, parent.right);
        } else { //RR
            rotate(grand, grand.left, grand, parent.left, parent, node.left, node, node.right);
        }
    }
}

删除节点导致的失衡

示例：删除下面这棵子树中的16
可能会导致父节点或祖先节点失衡（只有1个节点会失衡）
其他节点，都不可能失衡

第八章平衡二叉搜索树、AVL树_leetcode_19

第八章平衡二叉搜索树、AVL树_leetcode_20

LL – 右旋转（单旋）

如果绿色节点不存在，更高层的祖先节点可能也会失衡，需要再次恢复平衡，然后又可能导致更高层的祖先节点失衡…
极端情况下，所有祖先节点都需要进行恢复平衡的操作，共O(logn)次调整

第八章平衡二叉搜索树、AVL树_leetcode_21

RR – 左旋转（单旋）

第八章平衡二叉搜索树、AVL树_数据结构_22

LR – RR左旋转，LL右旋转（双旋）

第八章平衡二叉搜索树、AVL树_平衡二叉树_23

RL – LL右旋转，RR左旋转（双旋）

第八章平衡二叉搜索树、AVL树_平衡二叉树_24

删除之后的修复

@Override
protected void afterRemove(Node<E> node) {
    while ((node = node.parent) != null) {
        if (isBalanced(node)) {
            //更新高度
            updateHeight(node);
        } else {
            //恢复平衡
            rebalance(node);
        }
    }
}

AVL树总结

添加

可能会导致所有祖先节点都失衡
只要让高度最低的失衡节点恢复平衡，整棵树就恢复平衡【仅需 O(1) 次调整】

删除

可能会导致父节点或祖先节点失衡（只有1个节点会失衡）

恢复平衡后，可能会导致更高层的祖先节点失衡【最多需要 O(logn) 次调整】
平均时间复杂度

搜索：O(logn)
添加：O(logn)，仅需 O(1) 次的旋转操作
删除：O(logn)，最多需要 O(logn) 次的旋转操作

AVL树完整源码

package cn.xx.java.tree;

import java.util.Comparator;

/**
 * AVL树
 *
 * @author xiexu
 * @create 2021-08-03 10:49 上午
 */
public class AVLTree<E> extends BST<E> {
    public AVLTree() {
        this(null);
    }

    public AVLTree(Comparator<E> comparator) {
        super(comparator);
    }

    /**
     * 添加节点之后的操作
     *
     * @param node 新添加的节点
     */
    @Override
    protected void afterAdd(Node<E> node) {
        while ((node = node.parent) != null) {
            if (isBalanced(node)) { //当前节点是平衡的
                //更新高度
                updateHeight(node);
            } else {
                /**
                 * 恢复平衡
                 * 进去里面的node就是高度最低的那个不平衡节点
                 */
                rebalance(node);
                //整棵树恢复平衡
                break;
            }
        }
    }

    /**
     * 删除节点之后的操作
     *
     * @param node 被删除的节点
     */
    @Override
    protected void afterRemove(Node<E> node) {
        while ((node = node.parent) != null) {
            if (isBalanced(node)) {
                //更新高度
                updateHeight(node);
            } else {
                //恢复平衡
                rebalance(node);
            }
        }
    }

    /**
     * 重写父类中的 createNode
     *
     * @param element
     * @param parent
     * @return
     */
    @Override
    protected Node<E> createNode(E element, Node<E> parent) {
        return new AVLNode<>(element, parent);
    }

    /**
     * 恢复平衡
     *
     * @param grand 高度最低的那个不平衡节点
     */
    private void rebalance2(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
                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 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.left, node, node.right, parent, parent.right, grand, grand.right);
            } else { //LR
                rotate(grand, parent.left, parent, node.left, node, node.right, grand, grand.right);
            }
        } else { //R
            if (node.isLeftChild()) { //RL
                rotate(grand, grand.left, grand, node.left, node, node.right, parent, parent.right);
            } else { //RR
                rotate(grand, grand.left, grand, parent.left, parent, node.left, node, node.right);
            }
        }
    }

    private void rotate(
            Node<E> r, //子树的根节点
            Node<E> a, Node<E> b, Node<E> c,
            Node<E> d,
            Node<E> e, Node<E> f, Node<E> g) {
        //让d成为这棵子树的根节点
        d.parent = r.parent;
        if (r.isLeftChild()) { // r是父节点的左子节点
            r.parent.left = d;
        } else if (r.isRightChild()) { // r是父节点的右子节点
            r.parent.right = d;
        } else { // r是根节点
            root = d;
        }

        // a - b - c
        b.left = a;
        if (a != null) {
            a.parent = b;
        }
        b.right = c;
        if (c != null) {
            c.parent = b;
        }
        updateHeight(b); //更新b的高度

        // e - f - g
        f.left = e;
        if (e != null) {
            e.parent = f;
        }
        f.right = g;
        if (g != null) {
            g.parent = f;
        }
        updateHeight(f); //更新f的高度

        // b - d - f
        d.left = b;
        d.right = f;
        b.parent = d;
        f.parent = d;
        updateHeight(d); //更新d的高度
    }

    /**
     * 左旋
     *
     * @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);
    }

    /**
     * 公共代码：不管是左旋转、右旋转，都要执行
     *
     * @param grand  失衡节点
     * @param parent
     * @param 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 = parent;
        }

        //更新child的parent
        if (child != null) {
            child.parent = grand;
        }

        //更新grand的parent
        grand.parent = parent;

        //更新高度
        updateHeight(grand);
        updateHeight(parent);
    }

    /**
     * 判断传入节点是否平衡
     *
     * @param node
     * @return
     */
    private boolean isBalanced(Node<E> node) {
        return Math.abs(((AVLNode<E>) node).balanceFactor()) <= 1;
    }

    /**
     * 更新高度
     *
     * @param node
     */
    private void updateHeight(Node<E> node) {
        ((AVLNode<E>) node).updateHeight();
    }

    /**
     * AVL树节点
     *
     * @param <E>
     */
    private static class AVLNode<E> extends Node<E> {

        int height = 1; //叶子节点的默认高度就是1

        public AVLNode(E element, Node<E> parent) {
            super(element, parent);
        }

        /**
         * 返回当前节点的平衡因子
         *
         * @return
         */
        public int balanceFactor() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            return leftHeight - rightHeight;
        }

        /**
         * 更新节点的高度
         */
        public void updateHeight() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            height = 1 + Math.max(leftHeight, rightHeight);
        }

        /**
         * 返回高度较高的那个子节点
         * 因为p总是左右子树中高度最高的那个节点
         * n也总是左右子树中高度最高的那个节点
         *
         * @return
         */
        public Node<E> tallerChild() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            if (leftHeight > rightHeight) {
                return left;
            }
            if (leftHeight < rightHeight) {
                return right;
            }
            /**
             * 左右高度相同，就返回与父节点的子节点同方向的那个节点
             */
            return isLeftChild() ? left : right;
        }

        @Override
        public String toString() {
            String parentString = "null";
            if (parent != null) {
                parentString = parent.element.toString();
            }
            return element + "_p(" + parentString + ")_h(" + height + ")";
        }
    }
}

练习

110_平衡二叉树

第八章平衡二叉搜索树、AVL树_数据结构_25

package 二叉树;

/**
 * https://leetcode-cn.com/problems/balanced-binary-tree/
 *
 * @author xiexu
 * @create 2021-08-04 11:50 上午
 */
public class _110_平衡二叉树 {

    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }

    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = getHeight(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        // 左右子树高度差大于1，return -1表示已经不是平衡树了
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return Math.max(leftHeight, rightHeight) + 1;
    }

}