【ShuQiHere】AVL 树（AVL Tree）：如何保持二叉搜索树的平衡性？

【ShuQiHere】🌳

引言

在数据结构的世界里，二叉搜索树（Binary Search Tree, BST） 是一种非常常见的数据结构。虽然它允许快速的查找、插入和删除操作，但如果树变得不平衡，这些操作的时间复杂度将从理想的 O(log n) 退化为 O(n)。为了解决这个问题，AVL 树（AVL Tree） 提供了一种自平衡机制，能够通过控制树的高度来保持高效的操作性能。

AVL 树是由 Adelson-Velsky 和 Landis 于 1962 年发明的，它是第一种自平衡的二叉搜索树。本文将详细讲解 AVL 树的基本概念、插入和删除操作、旋转机制，以及它在实际应用中的意义。

---

1. 什么是 AVL 树？（AVL Tree）🌱

AVL 树的定义

AVL 树 是一种自平衡的二叉搜索树（Self-balancing Binary Search Tree），它的关键特性是：

1. 每个节点的**左子树（Left Subtree）和右子树（Right Subtree）**的高度差（平衡因子，Balance Factor）不超过 1。
2. 平衡因子的取值范围是 -1、0 和 1，如果任何节点的平衡因子超出这个范围，树就需要进行旋转操作来恢复平衡。

AVL 树的这种平衡机制能够确保所有的基本操作，如查找、插入和删除，时间复杂度都保持在 O(log n)。

平衡因子（Balance Factor）

AVL 树中，每个节点都有一个平衡因子，表示左子树与右子树的高度差。计算公式为：
[
$$\text{平衡因子}=\text{左子树的高度}-\text{右子树的高度}$$
]
当平衡因子为 -1、0 或 1 时，节点处于平衡状态；如果超出该范围，树需要进行调整。

例子：平衡的 AVL 树

      30
     /  \
   20   40
  /  \
10   25

在此 AVL 树中，每个节点的平衡因子都在 -1 到 1 之间，因此树保持平衡。

---

2. 插入操作：如何保持 AVL 树的平衡性？ 🌿

在 AVL 树中，插入操作的基本步骤与普通二叉搜索树相同，首先按照 BST 的规则插入节点。插入新节点后，可能会导致树失衡，此时需要通过旋转操作恢复平衡。

插入的步骤

1. 按照 BST 规则插入新节点：找到合适位置插入新节点。
2. 向上回溯检查平衡因子：从插入点向上检查每个节点的平衡因子，确定是否失衡。
3. 进行旋转操作恢复平衡：根据节点失衡的情况，执行单旋转或双旋转操作恢复平衡。

四种失衡情况与旋转操作

1. 左-左失衡（Left-Left, LL）：左子树的左子树插入新节点，执行**右旋（Right Rotation）**恢复平衡。
2. 右-右失衡（Right-Right, RR）：右子树的右子树插入新节点，执行**左旋（Left Rotation）**恢复平衡。
3. 左-右失衡（Left-Right, LR）：左子树的右子树插入新节点，先左旋左子树，再右旋。
4. 右-左失衡（Right-Left, RL）：右子树的左子树插入新节点，先右旋右子树，再左旋。

代码示例：旋转操作

// 右旋转操作
public Node rotateRight(Node y) {
    Node x = y.left;
    Node T2 = x.right;

    // 执行旋转
    x.right = y;
    y.left = T2;

    // 更新高度
    y.height = Math.max(height(y.left), height(y.right)) + 1;
    x.height = Math.max(height(x.left), height(x.right)) + 1;

    return x;  // 返回新的根节点
}

// 左旋转操作
public Node rotateLeft(Node x) {
    Node y = x.right;
    Node T2 = y.left;

    // 执行旋转
    y.left = x;
    x.right = T2;

    // 更新高度
    x.height = Math.max(height(x.left), height(x.right)) + 1;
    y.height = Math.max(height(y.left), height(y.right)) + 1;

    return y;  // 返回新的根节点
}

例子：左-左失衡（LL）

      30                       20
     /  \                     /  \
   20   40      右旋         10   30
  /  \          ------>           /  \
10   25                         25   40

插入节点后，节点 30 的左子树变得过高，出现左-左失衡，此时需要执行右旋转操作恢复平衡。

---

3. 删除操作：如何在 AVL 树中恢复平衡？ ❌

删除操作相对复杂，因为删除节点可能会导致多个节点失衡。删除节点的基本步骤如下：

1. 删除节点：按照 BST 规则找到并删除节点。
2. 检查并恢复平衡：从删除点向上检查每个节点的平衡因子，确定是否失衡。
3. 执行旋转操作：根据节点失衡的情况，执行相应的旋转操作恢复平衡。

删除后的旋转

删除操作后，可能会出现类似插入后的失衡，需要通过旋转操作来恢复平衡。常见的失衡情况有：

• 如果删除节点导致左子树比右子树高，执行右旋或双旋恢复平衡。
• 如果删除节点导致右子树比左子树高，执行左旋或双旋恢复平衡。

代码示例：删除操作

public Node deleteNode(Node root, int key) {
    if (root == null) {
        return root;
    }

    // BST 删除操作
    if (key < root.key) {
        root.left = deleteNode(root.left, key);
    } else if (key > root.key) {
        root.right = deleteNode(root.right, key);
    } else {
        if ((root.left == null) || (root.right == null)) {
            Node temp = (root.left != null) ? root.left : root.right;
            if (temp == null) {
                root = null;
            } else {
                root = temp;
            }
        } else {
            Node temp = minValueNode(root.right);
            root.key = temp.key;
            root.right = deleteNode(root.right, temp.key);
        }
    }

    if (root == null) return root;

    // 更新高度
    root.height = Math.max(height(root.left), height(root.right)) + 1;

    // 检查并恢复平衡
    int balance = getBalance(root);
    if (balance > 1 && getBalance(root.left) >= 0) {
        return rotateRight(root);
    }
    if (balance > 1 && getBalance(root.left) < 0) {
        root.left = rotateLeft(root.left);
        return rotateRight(root);
    }
    if (balance < -1 && getBalance(root.right) <= 0) {
        return rotateLeft(root);
    }
    if (balance < -1 && getBalance(root.right) > 0) {
        root.right = rotateRight(root.right);
        return rotateLeft(root);
    }

    return root;
}

删除操作的例子

假设有以下 AVL 树：

      50
     /  \
   30    70
  /  \   /
20   40 60

删除节点 20 后，节点 30 的平衡因子变为 -2，此时需要进行右旋操作，恢复树的平衡。删除后的树结构为：

      50
     /  \
   40    70
  /     /
30     60

---

4. AVL 树的复杂度分析

AVL 树的操作在最坏情况下仍然能够保持高效，时间复杂度为 O(log n)，因为 AVL 树通过旋转操作始终保持平衡，树的高度不会超过 O(log n)。

• 查找（Search）、插入（Insertion） 和 删除（Deletion） 的

时间复杂度均为 O(log n)。

• 旋转操作的时间复杂度为 O(1)，因为旋转操作仅涉及有限个节点的调整。

虽然 AVL 树的插入和删除操作比普通 BST 略复杂，因为需要进行旋转操作，但其自平衡机制带来的性能提升弥补了这一额外开销。

---

5. AVL 树的应用场景

由于 AVL 树能够在最坏情况下提供 O(log n) 的操作效率，因此它在以下应用场景中非常有用：

• 数据库索引（Database Indexing）：AVL 树的快速查找、插入和删除操作使其成为构建数据库索引的理想选择。
• 内存管理（Memory Management）：操作系统中使用 AVL 树来管理内存分配，确保高效的内存操作。
• 文件系统（File System）：AVL 树能够管理文件系统中的目录结构，提供快速的文件查找与更新。

---

结论：AVL 树的优势与局限性 🌟

AVL 树通过引入旋转操作和严格的平衡性检查，确保树的高度始终保持在 O(log n)，使得所有操作的时间复杂度保持在 O(log n)。这使得 AVL 树成为一种高效的自平衡二叉搜索树，特别适合动态数据管理场景。尽管 AVL 树的插入和删除操作较普通 BST 复杂，但其带来的平衡性保证了更优的性能。在许多应用中，AVL 树是构建高效数据结构的理想选择。