AVL 树 创建

一、概述

可视化网站 AVL Tree Visualzation (usfca.edu)

在二叉搜索树章节中，我们提到了在多次插入和删除操作后，二叉搜索树可能退化为链表。这种情况下，所

有操作的时间复杂度将从 𝑂(log 𝑛) 恶化为 𝑂(𝑛)。

如图所示，经过两次删除节点操作，这个二叉搜索树便会退化为链表。

二、AVL 树常见术语

AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为「平衡二叉搜索

树 balanced binary search tree」。

1. 节点高度

由于 AVL 树的相关操作需要获取节点高度，因此我们需要为节点类添加 height 变量。

2、节点定义如下：

public class TreeNode<E extends Comparable<E>> {

    // 节点值
    private E val;

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    // 节点高度
    private int height;

    // 左节点
    private TreeNode<E> left;

    // 右节点
    private TreeNode<E> right;

    // 构造函数
    public TreeNode(E val) {
        this.val = val;
    }

    public E getVal() {
        return val;
    }

    public void setVal(E val) {
        this.val = val;
    }


    public TreeNode<E> getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode<E> getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}

三、创建AVL树

1、节点高度

节点高度"是指从该节点到最远叶节点的距离，即所经过的"边"的数量。需要特别注意的是，叶节点的高度为 0 ，而空节点的高度为 ‑1 。我们将创建两个工具函数，分别用于获取和更新节点的高度。

/**
 * 求节点的高度
 * @param node 节点
 * @return
 */
private int getHeight(TreeNode<E> node) {
    return node == null ? 0 : node.getHeight();
}


/**
 * 更新节点高度
 * @param node 节点
 */
void updateHeight(TreeNode<E> node) {
    // 节点高度等于最高子树高度 + 1
    int leftHeight = getHeight(node.getLeft());
    int rightHeight = getHeight(node.getRight());
    node.setHeight(Math.max(leftHeight,rightHeight) + 1);
}

2、节点平衡因子

节点的「平衡因子 balance factor」定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为 0 。我们同样将获取节点平衡因子的功能封装成函数，方便后续使用。

/**
 * 计算平衡英子
 * @param node 节点
 * @return
 */
private int getBalanceFactor(TreeNode<E> node) {
    // 空节点平衡因子为 0
    if(node == null) {
        return 0;
    }
    // 节点平衡因子 = 左子树高度 - 右子树高度
    return getHeight(node.getLeft()) - getHeight(node.getRight());
}

• 设平衡因子为 𝑓 ，则一棵 AVL 树的任意节点的平衡因子皆满足 −1 ≤ 𝑓 ≤ 1 。

3、AVL 树旋转

AVL 树的特点在于"旋转"操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平衡。换句话说，旋转操作既能保持"二叉搜索树"的性质，也能使树重新变为"平衡二叉树"。

我们将平衡因子绝对值 > 1 的节点称为"失衡节点"。根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋。下面我们将详细介绍这些旋转操作。

1. 右旋

为了方便理解，我们把数据结构：平衡二分搜索树的LL旋转图示拿过来。

/**
 * 右旋操作
 * @param node 失衡节点
 * @return
 */
private TreeNode<E> rightRotate(TreeNode<E> node) {
    // 暂存节点B
    TreeNode<E> leftChild = node.getLeft();
    // 暂存节点E，A的左孩子的右孩子
    TreeNode<E> leftChildRightChild = leftChild.getRight();
    // 右旋转
    // 节点A作为节点B的右孩子
    leftChild.setRight(node);
    // 节点E作为节点A的左孩子
    node.setLeft(leftChildRightChild);
    // 更新节点的Height，只有节点A和节点B的高度发生了变化
    updateHeight(node);
    updateHeight(leftChild);
    // 返回节点B，新的根节点
    return leftChild;
}

2、左旋操作

当节点 child 有左子节点（记为 grandChild ）时，需要在左旋中添加一步：将 grandChild 作为 node 的右子节点。

可以观察到，右旋和左旋操作在逻辑上是镜像对称的，它们分别解决的两种失衡情况也是对称的。基于对称性，我们只需将右旋的实现代码中的所有的 left 替换为 right ，将所有的 right 替换为 left ，即可得到左

旋的实现代码。

/**
 * 左旋操作
 * @param node 失衡节点
 * @return
 */
private TreeNode<E> leftRotate(TreeNode<E> node) {
    // 暂存节点B
    TreeNode<E> child = node.getRight();
    // 暂存节点E，A的左孩子的右孩子
    TreeNode<E> grandChild = child.getLeft();
    // 以 child 为原点，将 node 向左旋转
    child.setLeft(node);
    node.setRight(grandChild);
    // 更新节点的Height，只有节点A和节点B的高度发生了变化
    updateHeight(node);
    updateHeight(child);
    // 返回节点B，新的根节点
    return child;
}

3、先左旋后右旋

对于图中的失衡节点 3 ，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先对 child 执行"左旋"，再对 node 执行"右旋"。

4、先右旋后左旋

如图所示，对于上述失衡二叉树的镜像情况，需要先对 child 执行"右旋"，然后对 node 执行"左旋"。

5、旋转的选择

下图展示的四种失衡情况与上述案例逐个对应，分别需要采用右旋、左旋、先右后左、先左后右的旋转操作。

如下表所示，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。

为了便于使用，我们将旋转操作封装成一个函数。有了这个函数，我们就能对各种失衡情况进行旋转，使失衡节点重新恢复平衡。

/**
  * 翻转
  * @param node
  * @return
  */
private TreeNode<E> rotate(TreeNode<E> node) {
     // 获取节点 node 的平衡因子
     int balanceFactor = getBalanceFactor(node);
     // 左偏树
     if (balanceFactor > 1) {
         if (getBalanceFactor(node.getLeft()) >= 0) {
             // 右旋
             return rightRotate(node);
         } else {
             // 先左旋后右旋
             node.setLeft(leftRotate(node.getLeft()));
             return rightRotate(node);
         }
     }
     // 右偏树
     if (balanceFactor < -1) {
         if (getBalanceFactor(node.getRight()) <= 0) {
             // 左旋
             return leftRotate(node);
         } else {
             // 先右旋后左旋
             node.setRight(rightRotate(node.getRight()));
             return leftRotate(node);
         }
     }
     // 平衡树，无须旋转，直接返回
     return node;
 }

4、AVL树常用操作

1、插入节点

AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区别在于，在 AVL 树中插入节点后，从该节点到根节点的路径上可能会出现一系列失衡节点。因此，我们需要从这个节点开始，自底向上执行旋转操作，使所有失衡节点恢复平衡。

/* 插入节点 */
public void insert(E val) {
     root = insertHelper(root, val);
 }

 /* 递归插入节点（辅助方法） */
private TreeNode<E> insertHelper(TreeNode<E> node, E val) {
    if (node == null) {
         return new TreeNode(val);
    }
    // 获取节点值
    E nodeVal = node.getVal();
    int compareTo = val.compareTo(nodeVal);

    /* 1. 查找插入位置，并插入节点 */
     if (compareTo < 0) {
         node.setLeft(insertHelper(node.getLeft(), val));
     } else if (compareTo > 0) {
         node.setRight(insertHelper(node.getRight(), val));
     } else {
         return node; // 重复节点不插入，直接返回
     }
     // 更新节点高度
     updateHeight(node);
     /* 2. 执行旋转操作，使该子树重新恢复平衡 */
     node = rotate(node);
     // 返回子树的根节点
     return node;
 }

2、删除节点

类似地，在二叉搜索树的删除节点方法的基础上，需要从底至顶地执行旋转操作，使所有失衡节点恢复平衡。

 /* 删除节点 */
 public void remove(E val) {
     root = removeHelper(root, val);
 }

 /* 递归删除节点（辅助方法） */
private TreeNode removeHelper(TreeNode<E> node, E val) {
     if (node == null) {
         return null;
     }
    int compareTo = val.compareTo(node.getVal());

    /* 1. 查找节点，并删除之 */
     if (compareTo < 0) {
         node.setLeft(removeHelper(node.getLeft(), val));
     }
     else if (compareTo > 0) {
         node.setRight(removeHelper(node.getRight(), val));
     } else {
         if (node.getLeft() == null || node.getRight() == null) {
             TreeNode<E> child = node.getLeft() != null ? node.getLeft() : node.getRight();
             // 子节点数量 = 0 ，直接删除 node 并返回
             if (child == null) {
                 return null;
             }
             // 子节点数量 = 1 ，直接删除 node
             else {
                 node = child;
             }
         } else {
             // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
             TreeNode<E> temp = node.getRight();
             while (temp.getLeft() != null) {
                 temp = temp.getLeft();
             }
             node.setRight(removeHelper(node.getRight(), temp.getVal()));
             node.setVal(temp.getVal());
         }
     }
     updateHeight(node); // 更新节点高度
     /* 2. 执行旋转操作，使该子树重新恢复平衡 */
     node = rotate(node);
     // 返回子树的根节点
     return node;
 }

3、bfs层序遍历

/**
 * 层序遍历
 * @return
 */
public List<E> bfsTraversal() {
    ArrayList<E> ts = new ArrayList<>();
    bfsTraversal(root,ts);
    return ts;
}

private void  bfsTraversal(TreeNode<E> binaryNode,List<E> result) {
    // 借助队列
    Queue<TreeNode<E>> queue = new ArrayDeque();
    if (binaryNode != null) {
        queue.add(binaryNode);
    }
    // 队列不为空
    while (!queue.isEmpty() ) {
        // 出队
        binaryNode = queue.poll();
        result.add(binaryNode.getVal());
        // 左边有节点
        if (binaryNode.getLeft() != null) {
            queue.add(binaryNode.getLeft());
        }
        // 右边有节点
        if (binaryNode.getRight() != null) {
            queue.add(binaryNode.getRight());
        }
    }

}

四、测试demo

1、原来树结构如下：

插入后

删除 4之后