AVL树：自平衡二叉搜索树的核心原理

原创于 2026-06-26 13:19:55 发布 · 242 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#算法 #数据结构 #c++ #开发语言

前言:

AVL 树。它由两位苏联数学家 Adelson-Velsky 和 Landis 在 1962 年发明，是史上第一个自平衡二叉搜索树，也是理解红黑树和所有平衡树思想的基础。

1. 什么是 AVL 树？

AVL 树是一种严格平衡的二叉搜索树，它满足：

任意节点的左子树高度与右子树高度之差（称为平衡因子）的绝对值不超过 1。

平衡因子 bf = height(left) - height(right)，取值只能是 -1、0、1。

因为高度差被严格限制，AVL 树能保证树高始终是 O(log n)，从而所有基本操作（查找、插入、删除）的最坏时间复杂度都是 O(log n)。

2. 为什么需要 AVL 树？

在普通 BST 中，依次插入 1, 2, 3, 4, 5 会变成：

高度变成 5，查找 5 要走 5 步。而 AVL 树通过旋转操作，会把树调整为近似完全二叉树的形态，保持树高在 1.44 * log2(n) 以内。同样的数据，AVL 树大概是：

查找效率高得多。

3. AVL 树节点的定义

相比 BST 节点，我们需要增加一个 height 字段来记录以该节点为根的子树高度。高度定义为左右子树高度的最大值 + 1，空节点高度视为 0。

struct AVLNode {
    int key;
    AVLNode* left;
    AVLNode* right;
    int height;

    AVLNode(int k) : key(k), left(nullptr), right(nullptr), height(1) {}
};

常用辅助函数：

int height(AVLNode* node) {
    return node ? node->height : 0;
}

int getBalance(AVLNode* node) {
    return node ? height(node->left) - height(node->right) : 0;
}

void updateHeight(AVLNode* node) {
    if (node) {
        node->height = std::max(height(node->left), height(node->right)) + 1;
    }
}

4. 旋转操作 —— AVL 树的核心

当插入或删除节点后，某节点的平衡因子变为 2 或 -2，就需要通过旋转来恢复平衡。旋转共四种情况。

4.1 右旋（Right Rotation）——解决“左左”失衡

当节点的左子树的左侧插入导致不平衡（bf > 1 且左孩子的 bf >= 0），进行一次右旋。

     y                 x
    / \               / \
   x   T3   --->    T1   y
  / \                   / \
 T1  T2               T2  T3

代码：

AVLNode* rightRotate(AVLNode* y) {
    AVLNode* x = y->left;
    AVLNode* T2 = x->right;

    // 旋转
    x->right = y;
    y->left = T2;

    // 更新高度（先更新 y，再更新 x）
    updateHeight(y);
    updateHeight(x);

    return x;  // 新的根
}

4.2 左旋（Left Rotation）——解决“右右”失衡

当节点的右子树的右侧插入导致不平衡（bf < -1 且右孩子的 bf <= 0），进行一次左旋。

     x                 y
    / \               / \
  T1   y     --->    x   T3
      / \           / \
     T2  T3       T1  T2

代码：

AVLNode* leftRotate(AVLNode* x) {
    AVLNode* y = x->right;
    AVLNode* T2 = y->left;

    y->left = x;
    x->right = T2;

    updateHeight(x);
    updateHeight(y);

    return y;
}

4.3 左右旋（Left-Right Rotation）——解决“左右”失衡

当节点左子树的右侧插入导致不平衡（bf > 1 且左孩子的 bf < 0），需要先对左子树做左旋，再对当前节点做右旋。

    y               y               z
    / \             / \             / \
   x   T3  --->    z   T3  --->    x   y
  / \             / \             / \ / \
 T1  z           x  T2          T1 T2 T3
    / \         / \
   T2 T3       T1 T2

代码（调用上面两个旋转）：

AVLNode* leftRightRotate(AVLNode* y) {
    y->left = leftRotate(y->left);   // 左旋左孩子
    return rightRotate(y);           // 右旋自己
}

4.4 右左旋（Right-Left Rotation）——解决“右左”失衡

当节点右子树的左侧插入导致不平衡（bf < -1 且右孩子的 bf > 0），先对右子树做右旋，再对当前节点做左旋。

     x               x               z
    / \             / \             / \
  T1   y    --->   T1  z    --->   x   y
      / \             / \         / \ / \
     z   T4          T2  y       T1 T2 T4
    / \                 / \
   T2 T3               T3 T4

代码：

AVLNode* rightLeftRotate(AVLNode* x) {
    x->right = rightRotate(x->right);
    return leftRotate(x);
}

5. 插入操作

插入和 BST 一样递归进行，插入后回溯更新高度，并检查平衡因子，一旦失衡立即做对应旋转。

AVLNode* insert(AVLNode* node, int key) {
    // 1. 普通 BST 插入
    if (!node)
        return new AVLNode(key);

    if (key < node->key)
        node->left = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);
    else
        return node;   // 重复键不插入

    // 2. 更新当前节点高度
    updateHeight(node);

    // 3. 计算平衡因子，检查是否失衡
    int balance = getBalance(node);

    // 左左情况
    if (balance > 1 && key < node->left->key)
        return rightRotate(node);

    // 右右情况
    if (balance < -1 && key > node->right->key)
        return leftRotate(node);

    // 左右情况
    if (balance > 1 && key > node->left->key) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }

    // 右左情况
    if (balance < -1 && key < node->right->key) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node; // 未失衡，直接返回
}

重要细节：每个 if 里的条件 key < node->left->key 等判断，确保了旋转的正确性。如果重复键存在，代码会直接返回，不会插入，也无需平衡。