树：二叉树、AVL树

「二叉树 binary tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的 分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含：值、左子节点引用、右子节点引用。

/* 二叉树节点类 */
class TreeNode {
    int val; // 节点值
    TreeNode left; // 左子节点引用
    TreeNode right; // 右子节点引用
    TreeNode(int x) { 
        val = x; 
    }
}

每个节点都有两个引用（指针），分别指向「左子节点 left‑child node」和「右子节点 right‑child node」，

该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子 节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。

在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树 。如图所示，如果将“节点 2”视为父 节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”， 右子树是“节点 5 及其以下节点形成的树”。

1.二叉树常见术语

‧「根节点 root node」：位于二叉树顶层的节点，没有父节点。

‧「叶节点 leaf node」：没有子节点的节点，其两个指针均指向 None 。

‧「边 edge」：连接两个节点的线段，即节点引用（指针）。

‧ 节点所在的「层 level」：从顶至底递增，根节点所在层为 1 。

‧ 节点的「度 degree」：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。

‧ 二叉树的「高度 height」：从根节点到最远叶节点所经过的边的数量。

‧ 节点的「深度 depth」：从根节点到该节点所经过的边的数量。

‧ 节点的「高度 height」：从距离该节点最远的叶节点到该节点所经过的边的数量。

2.二叉树的基本操作

1.初始化

   // 初始化节点
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);
        
        // 构建引用指向（即指针）
        n1.left = n2;
        n1.right = n3;
        n2.left = n4;
        n2.right = n5;

2.插入和删除

3.常见二叉树类型

1）.完美二叉树

完美二叉树（满二叉树） perfect binary tree」所有层的节点都被完全填满。在完美二叉树中，叶节点的度为 0 ，其余所 有节点的度都为 2 ；若树高度为 ℎ ，则节点总数为 2 的h+1次方-1 ，呈现标准的指数级关系，反映了自然界中常 见的细胞分裂现象。

2）.完全二叉树

全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左

填充。

3）.完满二叉树

「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。

4）. 平衡二叉树

「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不

超过 1 。

4.二叉树退化

下图展示了二叉树的理想与退化状态。当二叉树的每层节点都被填满时，达到“完美二叉树”；而当所有节 点都偏向一侧时，二叉树退化为“链表”。

‧ 完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。

‧ 链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 𝑂(𝑛) 。

二叉树最佳与最差情况对比

二叉树的最佳与最差情况

	完美二叉树	链表
第i层节点数量	2的i-1次方	1
高度 ℎ 树的叶节点数量	2的h次方	1
高度 ℎ 树的节点总数	2的h+1次方-1	h+1
节点总数 𝑛 树的高度	log 2 (𝑛 + 1) − 1	n-1

5.二叉树遍历

从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而， 树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现。

二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。

1).层序遍历

如下图所示，「层序遍历 level‑order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右 的顺序访问节点。

层序遍历本质上属于「广度优先遍历 breadth‑first traversal」，它体现了一种“一圈一圈向外扩展”的逐层遍历方式。

代码实现：

广度优先遍历通常借助“队列”来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进” 的规则，两者背后的思想是一致的。

public class Test1 {
    public static void main(String[] args) {
        // 初始化节点
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);

        // 构建引用指向（即指针）
        n1.left = n2;
        n1.right = n3;
        n2.left = n4;
        n2.right = n5;

        List<Integer> integers = levelOrder(n1);
        System.out.println(integers);
    }

    /* 层序遍历 */
    static List<Integer> levelOrder(TreeNode root) {
        // 初始化队列，加入根节点
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        // 初始化一个列表，用于保存遍历序列
        List<Integer> list = new ArrayList<>();
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll(); // 队列出队
            list.add(node.val); // 保存节点值
            if (node.left != null)
                queue.offer(node.left); // 左子节点入队
            if (node.right != null)
                queue.offer(node.right); // 右子节点入队
        }
        return list;
    }
}

1. 创建一个空队列，并将根节点入队。
2. 进入循环，直到队列为空： a. 出队当前节点。 b. 处理当前节点。 c. 如果当前节点有左孩子，将左孩子入队。 d. 如果当前节点有右孩子，将右孩子入队。

层序遍历的特点是，同一层的节点会先被处理，然后再处理下一层的节点。这保证了在输出结果中，同一层的节点是按照从左到右的顺序排列的。

‧ 时间复杂度 𝑂(𝑛) ：所有节点被访问一次，使用 𝑂(𝑛) 时间，其中 𝑛 为节点数量。

‧ 空间复杂度 𝑂(𝑛) ：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 (𝑛+1)/2 个节点，占用 𝑂(𝑛) 空间。

2).前序、中序、后序遍历

相应地，前序、中序和后序遍历都属于「深度优先遍历 depth‑first traversal」，它体现了一种“先走到尽头，

再回溯继续”的遍历方式。下图展示了对二叉树进行深度优先遍历的工作原理。深度优先遍历就像是绕着整个二叉树的外围“走”一 圈，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。

代码：

/* 前序遍历 */
void preOrder(TreeNode root) {
    if (root == null)return;
    // 访问优先级：根节点 -> 左子树 -> 右子树
    list.add(root.val);
    preOrder(root.left);
    preOrder(root.right);
}

/* 中序遍历 */
void inOrder(TreeNode root) {
    if (root == null)return;
    // 访问优先级：左子树 -> 根节点 -> 右子树
    inOrder(root.left);
    list.add(root.val);
    inOrder(root.right);
}
/* 后序遍历 */
void postOrder(TreeNode root) {
    if (root == null)return;
    // 访问优先级：左子树 -> 右子树 -> 根节点
    postOrder(root.left);
    postOrder(root.right);
    list.add(root.val);
}

‧ 时间复杂度 𝑂(𝑛) ：所有节点被访问一次，使用 𝑂(𝑛) 时间。

‧ 空间复杂度 𝑂(𝑛) ：在最差情况下，即树退化为链表时，递归深度达到 𝑛 ，系统占用 𝑂(𝑛) 栈帧空间

6.二叉树的数组表示

在链表表示下，二叉树的存储单元为节点 TreeNode ，节点之间通过指针相连接。在上节中，我们学习了在链表表示下的二叉树的各项基本操作。

那么，我们能否用数组来表示二叉树呢？答案是肯定的。

1.完美二叉树

给定一个完美二叉树，我们将所有节点按照层序遍历的顺序存储在一个数组中，则每个节点都对应唯一的数组索引。

根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”： 若节点的索引为 𝑖 ，则 该节点的左子节点索引为 2𝑖 + 1 ，右子节点索引为 2𝑖 + 2 。下图展示了各个节点索引之间的映射关系。

映射公式的角色相当于链表中的指针 。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左 （右）子节点。

2.任意二叉树

完美二叉树是一个特例，在二叉树的中间层通常存在许多 None 。由于层序遍历序列并不包含这些 None ， 因此我们无法仅凭该序列来推测 None 的数量和分布位置。这意味着存在多种二叉树结构都符合该层序遍历 序列 。

如下图所示，给定一个非完美二叉树，上述的数组表示方法已经失效。

为了解决此问题， 我们可以考虑在层序遍历序列中显式地写出所有 None 。如下图所示，这样处理后，层 序遍历序列就可以唯一表示二叉树了。

/* 二叉树的数组表示 */

// 使用 int 的包装类 Integer ，就可以使用 null 来标记空位

Integer [] tree = { 1 , 2 , 3 , 4 , null, 6 , 7 , 8 , 9 , null, null, 12 , null, null, 15 };

值得说明的是， 完全二叉树非常适合使用数组来表示 。回顾完全二叉树的定义，None 只出现在最底层且靠 右的位置，因此所有 None 一定出现在层序遍历序列的末尾 。

这意味着使用数组表示完全二叉树时，可以省略存储所有 None ，非常方便

以下代码实现了一个基于数组表示的二叉树，包括以下几种操作。

‧ 给定某节点，获取它的值、左（右）子节点、父节点。

‧ 获取前序遍历、中序遍历、后序遍历、层序遍历序列

package com.syctest.test1.test.model;

import java.util.ArrayList;
import java.util.List;

/* 数组表示下的二叉树类 */
public class ArrayBinaryTree {
    private List<Integer> tree;
    /* 构造方法 */
    public ArrayBinaryTree(List<Integer> arr) {
        tree = new ArrayList<>(arr);
    }

    /* 节点数量 */
    public int size() {
        return tree.size();
    }

    /* 获取索引为 i 节点的值 */
    public Integer val(int i) {
        // 若索引越界，则返回 null ，代表空位
        if (i < 0 || i >= size())
            return null;
        return tree.get(i);
    }

    /* 获取索引为 i 节点的左子节点的索引 */
    public Integer left(int i) {
        return 2 * i + 1;
    }
    /* 获取索引为 i 节点的右子节点的索引 */
    public Integer right(int i) {
        return 2 * i + 2;
    }
    /* 获取索引为 i 节点的父节点的索引 */
    public Integer parent(int i) {
        return (i - 1) / 2;
    }

    /* 层序遍历 */
    public List<Integer> levelOrder() {
        List<Integer> res = new ArrayList<>();
        // 直接遍历数组
        for (int i = 0; i < size(); i++) {
            if (val(i) != null)
                res.add(val(i));
        }
        return res;
    }

    /* 深度优先遍历 */
    private void dfs(Integer i, String order, List<Integer> res) {
        // 若为空位，则返回
        if (val(i) == null)
            return;

        // 前序遍历
        if (order == "pre")
            res.add(val(i));
            dfs(left(i), order, res);

        // 中序遍历
        if (order == "in")
            res.add(val(i));
            dfs(right(i), order, res);

        // 后序遍历
        if (order == "post")
            res.add(val(i));
    }

    /* 前序遍历 */
    public List<Integer> preOrder() {
        List<Integer> res = new ArrayList<>();
        dfs(0, "pre", res);
        return res;
    }
    /* 中序遍历 */
    public List<Integer> inOrder() {
        List<Integer> res = new ArrayList<>();
        dfs(0, "in", res);
        return res;
    }
    /* 后序遍历 */
    public List<Integer> postOrder() {
        List<Integer> res = new ArrayList<>();
        dfs(0, "post", res);
        return res;
    }


}

优点：

1. 空间利用率高： 数组不需要额外的指针来存储左右子节点的地址，因此相比链式结构，它在内存上的空间利用率更高。
2. 访问效率高： 通过索引直接访问节点，不需要通过指针进行遍历。
3. ‧ 允许随机访问节点。

然而，数组表示也存在一些局限性。

        1‧ 数组存储需要连续内存空间，因此不适合存储数据量过大的树。

        2‧ 增删节点需要通过数组插入与删除操作实现，效率较低。

        

        3‧ 当二叉树中存在大量 None 时，数组中包含的节点数据比重较低，空间利用率较低。

二叉搜索树

「二叉搜索树 binary search tree」满足以下条件。

1. 对于根节点，左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值。

2. 任意节点的左、右子树也是二叉搜索树，即同样满足条件 1. 。

操作：

我们将二叉搜索树封装为一个类 BinarySearchTree ，并声明一个成员变量 root ，指向树的根节点。

1. 查找节点

给定目标节点值 num ，可以根据二叉搜索树的性质来查找。如下图所示，我们声明一个节点 cur ，从二叉 树的根节点 root 出发，循环比较节点值 cur.val 和 num 之间的大小关系。

‧ 若 cur.val < num ，说明目标节点在 cur 的右子树中，因此执行 cur = cur.right 。

‧ 若 cur.val > num ，说明目标节点在 cur 的左子树中，因此执行 cur = cur.left 。

‧ 若 cur.val = num ，说明找到目标节点，跳出循环并返回该节点。

二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用 𝑂( log 𝑛) 时间。

代码：

/* 查找节点 */
TreeNode search(int num) {
    TreeNode cur = root;
    // 循环查找，越过叶节点后跳出
    while (cur != null) {
        // 目标节点在 cur 的右子树中
        if (cur.val < num)
            cur = cur.right;
            // 目标节点在 cur 的左子树中
        else if (cur.val > num)
            cur = cur.left;
            // 找到目标节点，跳出循环
        else
            break;
     }
        // 返回目标节点
        return cur;
}

2.插入

给定一个待插入元素 num ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作流程如图所示。

1. 查找插入位置 ：与查找操作相似，从根节点出发，根据当前节点值和 num 的大小关系循环向下搜索，直到越过叶节点（遍历至 None ）时跳出循环。

2. 在该位置插入节点 ：初始化节点 num ，将该节点置于 None 的位置。

在代码实现中，需要注意以下两点。

‧ 二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插 入，直接返回。

‧ 为了实现插入节点，我们需要借助节点 pre 保存上一轮循环的节点。这样在遍历至 None 时，我们可以 获取到其父节点，从而完成节点插入操作。

/* 插入节点 */
void insert(int num) {
    // 若树为空，则初始化根节点
    if (root == null) {
        root = new TreeNode(num);
        return;
    }
    TreeNode cur = root, pre = null;

    // 循环查找，越过叶节点后跳出
    while (cur != null) {
        // 找到重复节点，直接返回
        if (cur.val == num)
        return;
        pre = cur;
        // 插入位置在 cur 的右子树中
        if (cur.val < num)
            cur = cur.right;
            // 插入位置在 cur 的左子树中
        else
            cur = cur.left;
    }
    // 插入节点
    TreeNode node = new TreeNode(num);
    if (pre.val < num)
        pre.right = node;
    else
        pre.left = node;
}

与查找节点相同，插入节点使用 𝑂( log 𝑛) 时间。

3.删除

先在二叉树中查找到目标节点，再将其从二叉树中删除。

与插入节点类似，我们需要保证在删除操作完成后，二叉搜索树的“左子树 < 根节点 < 右子树”的性质仍然 满足。

因此，我们需要根据目标节点的子节点数量，共分为 0、1 和 2 这三种情况，执行对应的删除节点操作。

如图所示，当待删除节点的度（该节点的子节点数量）为 0 时，表示该节点是叶节点，可以直接删除。

当待删除节点的度为 1 时，将待删除节点替换为其子节点即可

当待删除节点的度为 2 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树 “左 < 根 < 右”的性质， 因此这个节点可以是右子树的最小节点或左子树的最大节点 。

假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作流程如图所示。

1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 tmp 。

2. 将 tmp 的值覆盖待删除节点的值，并在树中递归删除节点 tmp 。

删除节点操作同样使用 𝑂( log 𝑛) 时间，其中查找待删除节点需要 𝑂( log 𝑛) 时间，获取中序遍历后继节点 需要 𝑂( log 𝑛) 时间。

 void remove(int num) {
        // 若树为空，直接提前返回
        if (root == null) return;

        //cur存储要删除的节点  pre存储要删除节点的父节点
        TreeNode cur = root, pre = null;
        // 通过循环查找，找到待删除的节点。在查找的过程中，通过比较当前节点的值与目标值的大小，决定是往左子树还是右子树移动。
        while (cur != null) {
            // 找到待删除节点，跳出循环
            if (cur.val == num)
                break;
            pre = cur;//保存为要删除节点的父节点
            // 待删除节点在 cur 的右子树中
            if (cur.val < num)
                cur = cur.right;
                // 待删除节点在 cur 的左子树中
            else
                cur = cur.left;
        }

        // 若无待删除节点，则直接返回
        if (cur == null) return;

//        如果找到了待删除的节点，分为两种情况处理：
//            如果待删除节点的子节点数量为0或1，直接删除该节点。如果是根节点，重新指定根节点；如果是非根节点，将其父节点指向待删除节点的子节点。
//            如果待删除节点的子节点数量为2，找到中序遍历中的下一个节点，递归删除该下一个节点，然后用该下一个节点的值覆盖待删除节点的值。
        if (cur.left == null || cur.right == null) {//左右只要有一个为空，就是子节点数量为0或1
            // 当子节点数量 = 0 / 1 时， child = null / 该子节点
            TreeNode child = cur.left != null ? cur.left : cur.right;//取出要删除节点的不为空的那个子节点
            // 删除节点 cur
            if (cur != root) {//要删除节点不是根节点
                if (pre.left == cur)//此时pre为要删除节点cur的父节点
                    pre.left = child;//要删除的是父节点的左边的，将要删除节点的子节点覆盖要删除的节点
                else
                    pre.right = child;
            } else {
                // 若删除节点为根节点，则重新指定根节点
                root = child;
            }
        } else {// 子节点数量 = 2
            // 获取中序遍历中 cur 的下一个节点  中序遍历遵循“左 → 根 → 右”的遍历顺序
            TreeNode tmp = cur.right;
            while (tmp.left != null) {
                tmp = tmp.left;
            }
            // 递归删除节点 tmp
            remove(tmp.val);
            
            // 用 tmp 覆盖 cur
            cur.val = tmp.val;
        }
    }

4.中序遍历

如图 所示，二叉树的中序遍历遵循“左 → 根 → 右”的遍历顺序，而二叉搜索树满足“左子节点 < 根

节点 < 右子节点”的大小关系。

这意味着在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质： 二叉 搜索树的中序遍历序列是升序的 。

利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 𝑂(𝑛) 时间，无须进行额外的排序操作， 非常高效。

4.二叉搜索树的效率

给定一组数据，我们考虑使用数组或二叉搜索树存储。观察下表 ，二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜 索树的效率更高

在理想情况下，二叉搜索树是“平衡”的，这样就可以在 log 𝑛 轮循环内查找任意节点。

然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为下图所示的链表，这时各 种操作的时间复杂度也会退化为 𝑂(𝑛) 。

5.二叉搜索树的应用

1. 数据库索引： 数据库管理系统中，索引常常使用二叉搜索树来实现。通过在数据库表的某一列上建立索引，可以加快对该列的搜索和排序操作。

2. 符号表： 编译器和解释器中常用二叉搜索树来实现符号表，用于存储变量、函数等符号信息。

3. 字典： 二叉搜索树可以用作字典，其中键-值对按照键的顺序进行排序，使得查找、插入和删除等操作都能在较快的时间内完成。

4. 优先队列： 通过二叉搜索树实现的优先队列，可以在 O(log n) 的时间内实现插入和删除最大或最小元素的操作。

5. 文件系统： 文件系统中的目录结构通常可以使用二叉搜索树来组织，以便更有效地进行文件搜索和访问。

6. 网络路由表： 在计算机网络中，路由表的实现中也可以使用二叉搜索树，以加速对目标地址的查找操作。

7. 自平衡二叉搜索树： AVL树、红黑树等自平衡二叉搜索树的实现在算法和数据结构中有重要应用，用于确保树的平衡性，以提高性能。

8. 图形图像处理： 在图形学和图像处理中，二叉搜索树可以用于处理和搜索像素或图形数据。

9. 数值范围查询： 二叉搜索树的有序性使得在某个数值范围内进行查询变得高效，因此在一些数值处理场景中也有应用。

总体而言，二叉搜索树的有序性和高效的搜索、插入、删除操作使其在各种应用场景中都能发挥重要作用。然而，需要注意的是，为了避免退化成链表的情况，有时候会使用平衡二叉搜索树，如AVL树、红黑树等。

AVL树

在二叉搜索树章节中，我们提到了在多次插入和删除操作后，二叉搜索树可能退化为链表。这种情况下，所 有操作的时间复杂度将从 𝑂( log 𝑛) 恶化为 𝑂(𝑛) 。

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

再例如，在完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶

化。

G. M. Adelson‑Velsky 和 E. M. Landis 在其 1962 年发表的论文“An algorithm for the organization of information”中提出了「AVL 树」。论文中详细描述了一系列操作，确保在持续添加和删除节点后，AVL 树 不会退化，从而使得各种操作的时间复杂度保持在 𝑂( log 𝑛) 级别。换句话说，在需要频繁进行增删查改操 作的场景中，AVL 树能始终保持高效的数据操作性能，具有很好的应用价值。

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

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

@Data
@AllArgsConstructor
public class TreeNode {
    public int height; // 节点高度
    public int val; // 节点值
    public TreeNode left; // 左子节点引用
    public TreeNode right; // 右子节点引用
    public TreeNode(int x) {
        val = x;
    }

}

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

 节点平衡因子

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

AVL树旋转

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

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

1.右旋

如图所示，节点下方为平衡因子。从底至顶看，二叉树中首个失衡节点是“节点 3”。我们关注以该失衡 节点为根节点的子树，将该节点记为 node ，其左子节点记为 child ，执行“右旋”操作。完成右旋后，子树已经恢复平衡，并且仍然保持二叉搜索树的特性。

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

“向右旋转”是一种形象化的说法，实际上需要通过修改节点指针来实现，代码如下所示。

/* 右旋操作 */
TreeNode rightRotate(TreeNode node) {
    TreeNode child = node.left;
    TreeNode grandChild = child.right;
    // 以 child 为原点，将 node 向右旋转
    child.right = node;
    node.left = grandChild;
    // 更新节点高度
    updateHeight(node);
    updateHeight(child);
    // 返回旋转后子树的根节点
    return child;
}

2.左旋

相应的，如果考虑上述失衡二叉树的“镜像”，则需要执行下图所示的“左旋”操作

同理，如下图所示，当节点 child 有左子节点（记为 grandChild ）时，需要在左旋中添加一步：将

grandChild 作为 node 的右子节点。

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

/* 左旋操作 */
TreeNode leftRotate(TreeNode node) {
    TreeNode child = node.right;
    TreeNode grandChild = child.left;
    // 以 child 为原点，将 node 向左旋转
    child.left = node;
    node.right = grandChild;
    // 更新节点高度
    updateHeight(node);
    updateHeight(child);
    // 返回旋转后子树的根节点
    return child;
}

3. 先左旋后右旋

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

4. 先右旋后左旋

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

5.旋转的选择

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

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

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

 /* 执行旋转操作，使该子树重新恢复平衡 */
    TreeNode rotate(TreeNode node) {
        // 获取节点 node 的平衡因子
        int balanceFactor = balanceFactor(node);
        // 左偏树
        if (balanceFactor > 1) {
            if (balanceFactor(node.left) >= 0) {
                // 右旋
                return rightRotate(node);
            } else {
                // 先左旋后右旋
                node.left = leftRotate(node.left);
                return rightRotate(node);
            }
        }
        // 右偏树
        if (balanceFactor < -1) {
            if (balanceFactor(node.right) <= 0) {
                // 左旋
                return leftRotate(node);
            } else {
                // 先右旋后左旋
                node.right = rightRotate(node.right);
                return leftRotate(node);
            }
        }
        // 平衡树，无须旋转，直接返回
        return node;
    }

AVL 树常用操作

1. 插入节点

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

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

    /* 递归插入节点（辅助方法） */
    TreeNode insertHelper(TreeNode node, int val) {
        if (node == null)
            return new TreeNode(val);
        /* 1. 查找插入位置，并插入节点 */
        if (val < node.val)
            node.left = insertHelper(node.left, val);
        else if (val > node.val)
            node.right = insertHelper(node.right, val);
        else
            return node; // 重复节点不插入，直接返回
        updateHeight(node); // 更新节点高度
        /* 2. 执行旋转操作，使该子树重新恢复平衡 */
        node = rotate(node);
        // 返回子树的根节点
        return node;
    }

2. 删除节点

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

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

3. 查找节点

AVL 树的节点查找操作与二叉搜索树一致，在此不再赘述。

AVL 树典型应用

‧ 组织和存储大型数据，适用于高频查找、低频增删的场景。

‧ 用于构建数据库中的索引系统。

‧ 红黑树在许多应用中比 AVL 树更受欢迎。这是因为红黑树的平衡条件相对宽松，在红黑树中插入与删 除节点所需的旋转操作相对较少，其节点增删操作的平均效率更高。

小结

‧ 二叉树是一种非线性数据结构，体现“一分为二”的分治逻辑。每个二叉树节点包含一个值以及两个指针，分别指向其左子节点和右子节点。

‧ 对于二叉树中的某个节点，其左（右）子节点及其以下形成的树被称为该节点的左（右）子树。

‧ 二叉树的相关术语包括根节点、叶节点、层、度、边、高度和深度等。

‧ 二叉树的初始化、节点插入和节点删除操作与链表操作方法类似。

‧ 常见的二叉树类型有完美二叉树、完全二叉树、完满二叉树和平衡二叉树。完美二叉树是最理想的状态，而链表是退化后的最差状态。

‧ 二叉树可以用数组表示，方法是将节点值和空位按层序遍历顺序排列，并根据父节点与子节点之间的索引映射关系来实现指针。

‧ 二叉树的层序遍历是一种广度优先搜索方法，它体现了“一圈一圈向外”的分层遍历方式，通常通过队列来实现。

‧ 前序、中序、后序遍历皆属于深度优先搜索，它们体现了“走到尽头，再回头继续”的回溯遍历方式， 通常使用递归来实现。

‧ 二叉搜索树是一种高效的元素查找数据结构，其查找、插入和删除操作的时间复杂度均为 𝑂( log 𝑛) 。当二叉搜索树退化为链表时，各项时间复杂度会劣化至 𝑂(𝑛) 。

‧ AVL 树，也称为平衡二叉搜索树，它通过旋转操作，确保在不断插入和删除节点后，树仍然保持平衡。

‧ AVL 树的旋转操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或删除节点后，AVL 树会 从底向顶执行旋转操作，使树重新恢复平衡。

Q & A

对于只有一个节点的二叉树，树的高度和根节点的深度都是 0 吗？

是的，因为高度和深度通常定义为“走过边的数量”。

二叉树中的插入与删除一般都是由一套操作配合完成的，这里的“一套操作”指什么呢？可以

理解为资源的子节点的资源释放吗？

拿二叉搜索树来举例，删除节点操作要分为三种情况处理，其中每种情况都需要进行多个步

骤的节点操作。

为什么 DFS 遍历二叉树有前、中、后三种顺序，分别有什么用呢？

DFS 的前、中、后序遍历和访问数组的顺序类似，是遍历二叉树的基本方法，利用这三种遍

历方法，我们可以得到一个特定顺序的遍历结果。例如在二叉搜索树中，由于节点大小满足

左子节点值 < 根节点值 < 右子节点值 ，因此我们只要按照 左 -> 根 -> 右 的优先级遍历树，就

可以获得有序的节点序列。

右旋操作是处理失衡节点 node 、 child 、 grand_child 之间的关系，那 node 的父节点和 node 原

来的连接不需要维护吗？右旋操作后岂不是断掉了？

我们需要从递归的视角来看这个问题。右旋操作 right_rotate(root) 传入的是子树的根节点，

最终 return child 返回旋转之后的子树的根节点。子树的根节点和其父节点的连接是在该函

数返回后完成的，不属于右旋操作的维护范围。

在 C++ 中，函数被划分到 private 和 public 中，这方面有什么考量吗？为什么要将 height()

函数和 updateHeight() 函数分别放在 public 和 private 中呢？

主要看方法的使用范围，如果方法只在类内部使用，那么就设计为 private 。例如，用户单独

调用 updateHeight() 是没有意义的，它只是插入、删除操作中的一步。而 height() 是访问节

点高度，类似于 vector.size() ，因此设置成 public 以便使用。

请问如何从一组输入数据构建一个二叉搜索树？根节点的选择是不是很重要？

是的，构建树的方法已在二叉搜索树代码中的 build_tree() 方法中给出。至于根节点的选择，

我们通常会将输入数据排序，然后用中点元素作为根节点，再递归地构建左右子树。这样做可

以最大程度保证树的平衡性。

在 Java 中，字符串对比是否一定要用 equals() 方法？

在 Java 中，对于基本数据类型， == 用于对比两个变量的值是否相等。对于引用类型，两种符

号的工作原理是不同的。

‧ == ：用来比较两个变量是否指向同一个对象，即它们在内存中的位置是否相同。

‧ equals() ：用来对比两个对象的值是否相等。

因此如果要对比值，我们通常会用 equals() 。然而，通过 String a = "hi"; String b = "hi";

初始化的字符串都存储在字符串常量池中，它们指向同一个对象，因此也可以用 a == b 来比

较两个字符串的内容。

广度优先遍历到最底层之前，队列中的节点数量是 2 ℎ 吗？

是的，例如高度 ℎ = 2 的满二叉树，其节点总数 𝑛 = 7 ，则底层节点数量 4 = 2 ℎ = (𝑛+1)/2

。