树

1. 二叉树

二叉树(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)。 在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树。

1.1 二叉树常见术语

1. 根节点(root node)：位于二叉树顶层的节点，没有父节点。
2. 叶节点(leaf node)：没有子节点的节点，其两个指针均指向None。
3. 边(edge)：连接两个节点的线段，即节点引用(指针)。
4. 节点所在的层(level)：从顶至底递增，根节点所在层为1。
5. 节点的度(degree)：节点的子节点的数量。在二叉树中，度的取值范围是0、1、2。
6. 二叉树的高度(height)：从根节点到最远叶节点所经过的边的数量。
7. 节点的深度(depth)：从根节点到该节点所经过的边的数量。
8. 节点的高度(height)：从距离该节点最远的叶节点到该节点所经过的边的数量。

2. 二叉树基本操作

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.2 插入与删除节点

与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。

TreeNode P = new TreeNode(0);
// 在 n1 -> n2 中间插入节点 P
n1.left = P;
P.left = n2;
// 删除节点 P
n1.left = n2;

3. 常见二叉树类型

3.1 完美二叉树

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

3.2 完全二叉树

完全二叉树(complete binary tree)只有最底层的节点未被填满，且最底层节点尽量靠左填充。请注意，完美二叉树也是一棵完全二叉树。

3.3 完满二叉树

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

3.4 平衡二叉树

平衡二叉树(balanced binary tree)中任意节点的左子树和右子树的高度之差的绝对值不超过1。

3.5 二叉树的退化

下图展示了二叉树的理想结构与退化结构。当二叉树的每层节点都被填满时，达到"完美二叉树"；而当所有节点都偏向一侧时，二叉树退化为"链表"。完美二叉树是理想情况，可以充分发挥二叉树"分治"的优势。链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至O(n)。

4. 二叉树遍历

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

4.1 层序遍历

层序遍历(level-order traversal)从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。层序遍历本质上属于广度优先遍历(breadth-first traversal)，也称广度优先搜索(breadth-first search, BFS)，它体现了一种"一圈一圈向外扩展"的逐层遍历方式。

/* 层序遍历 */
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;
}

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

4.2 前序、中序、后序遍历

前序、中序和后序遍历都属于深度优先遍历(depth-first traversal)，也称深度优先搜索(depth-first search, DFS)，它体现了一种"先走到尽头，再回溯继续"的遍历方式。如图展示了对二叉树进行深度优先遍历的工作原理。深度优先遍历就像是绕着整棵二叉树的外围"走"一圈，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。

/* 前序遍历 */
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);
}

深度优先搜索通常基于递归实现。

5. 二叉树数组表示

二叉树也可以使用数组来实现。表示任意二叉树，需要考虑在层序遍历序列中显式地写出所有None节点信息,如图的二叉树用数组表示：

/* 二叉树的数组表示 */
// 使用 int 的包装类 Integer ，就可以使用 null 来标记空位
Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };

表示完全二叉树时，可以省略存储所有None，非常方便:
以下代码实现了一棵基于数组表示的二叉树，包括以下几种操作:

• 给定某节点，获取它的值、左(右)子节点、父节点。
• 获取前序遍历、中序遍历、后序遍历、层序遍历序列。

/* 数组表示下的二叉树类 */
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 ("pre".equals(order))
            res.add(val(i));
        dfs(left(i), order, res);
        // 中序遍历
        if ("in".equals(order))
            res.add(val(i));
        dfs(right(i), order, res);
        // 后序遍历
        if ("post".equals(order))
            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;
    }
}

二叉树的数组表示主要有以下优点:

• 数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快。
• 不需要存储指针，比较节省空间。
• 允许随机访问节点。
  然而，数组表示也存在一些局限性:
• 数组存储需要连续内存空间，因此不适合存储数据量过大的树。
• 增删节点需要通过数组插入与删除操作实现，效率较低。
• 当二叉树中存在大量None时，数组中包含的节点数据比重较低，空间利用率较低。

6. 二叉搜索树

如图所示，二叉搜索树(binary search tree)满足以下条件:

• 对于根节点，左子树中所有节点的值<根节点的值<右子树中所有节点的值。
• 任意节点的左、右子树也是二叉搜索树，即同样满足条件1。
  

7. 二叉搜索树的操作

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

7.1 查找节点

给定目标节点值num，可以根据二叉搜索树的性质来查找。如图所示，我们声明一个节点cur ，从二叉树的根节点root出发，循环比较节点值cur.val和num之间的大小关系:
若cur.val < num，说明目标节点在cur的右子树中，因此执行cur=cur.right。
若cur.val > num，说明目标节点在cur的左子树中，因此执行cur=cur.left。
若cur.val = num，说明找到目标节点，跳出循环并返回该节点。
二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用O(logn)时间。

/* 查找节点 */
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;
}

7.2 插入节点

给定一个待插入元素num，为了保持二叉搜索树"左子树<根节点<右子树"的性质，插入操作流程如图所示：
在代码实现中，需要注意以下两点：

• 二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。
• 为了实现插入节点，我们需要借助节点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;
}

与查找节点相同，插入节点使用O(logn)时间。

7.3 删除节点

先在二叉树中查找到目标节点，再将其删除。与插入节点类似，我们需要保证在删除操作完成后，二叉搜索树的"左子树<根节点<右子树"的性质仍然满足。因此，我们根据目标节点的子节点数量，分1、2和3三种情况，执行对应的删除节点操作。

1. 情况1
   当待删除节点的度为0时，表示该节点是叶节点，可以直接删除。
   
2. 情况2
   当待删除节点的度为1时，将待删除节点替换为其子节点即可。
3. 情况3
   当待删除节点的度为2时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树"左子树<根节点<右子树"的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。假设我们选择右子树的最小节点(中序遍历的下一个节点)，则删除操作流程如图所示:
   
   删除节点操作同样使用时间，其中查找待删除节点需要O(logn)时间，获取中序遍历后继节点需要O(logn)时间。

/* 删除节点 */
void remove(int num) {
    // 若树为空，直接提前返回
    if (root == null)
        return;
    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 or 1
    if (cur.left == null || cur.right == null) {
        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
        TreeNode child = cur.left != null ? cur.left : cur.right;
        // 删除节点 cur
        if (cur != root) {
            if (pre.left == cur)
                pre.left = child;
            else
                pre.right = child;
        } else {
            // 若删除节点为根节点，则重新指定根节点
            root = child;
        }
    }
    // 子节点数量 = 2
    else {
        // 获取中序遍历中 cur 的下一个节点
        TreeNode tmp = cur.right;
        while (tmp.left != null) {
            tmp = tmp.left;
        }
        // 递归删除节点 tmp
        remove(tmp.val);
        // 用 tmp 覆盖 cur
        cur.val = tmp.val;
    }
}

7.4 中序遍历有序

如图 7-22 所示，二叉树的中序遍历遵循"左➔根➔右"的遍历顺序，而二叉搜索树满足"左子节点<根节点<右子节点"的大小关系。这意味着在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：二叉搜索树的中序遍历序列是升序的。利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需O(n)时间，无须进行额外的排序操作，非常高效。

7.5 二叉搜索树的效率

二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能。只有在高频添加、低频查找删除数据的场景下，数组比二叉搜索树的效率更高。

7.6 二叉搜索树常见应用

• 用作系统中的多级索引，实现高效的查找、插入、删除操作。
• 作为某些搜索算法的底层数据结构。
• 用于存储数据流，以保持其有序状态。

8. AVL树

AVL树既是二叉搜索树，也是平衡二叉树，同时满足这两类二叉树的所有性质，因此是一种平衡二叉搜索树(balanced binary search tree)。在需要频繁进行增删查改操作的场景中，AVL树能始终保持高效的数据操作性能。

8.1 AVL树常见术语

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

/* 获取节点高度 */
int height(TreeNode node) {
    // 空节点高度为 -1 ，叶节点高度为 0
    return node == null ? -1 : node.height;
}

/* 更新节点高度 */
void updateHeight(TreeNode node) {
    // 节点高度等于最高子树高度 + 1
    node.height = Math.max(height(node.left), height(node.right)) + 1;
}

2. 节点平衡因子 节点的平衡因子(balance factor)定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为0。我们同样将获取节点平衡因子的功能封装成函数:

/* 获取平衡因子 */
int balanceFactor(TreeNode node) {
    // 空节点平衡因子为 0
    if (node == null)
        return 0;
    // 节点平衡因子 = 左子树高度 - 右子树高度
    return height(node.left) - height(node.right);
}

9. AVL树旋转

AVL树的特点在于"旋转"操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平衡。换句话说，旋转操作既能保持"二叉搜索树"的性质，也能使树重新变为"平衡二叉树"。 我们将平衡因子绝对值>1的节点称为"失衡节点"。根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋。下面详细介绍这些旋转操作。

9.1 右旋

如图所示，节点下方为平衡因子。从底至顶看，二叉树中首个失衡节点是"节点 3"。我们关注以该失衡节点为根节点的子树，将该节点记为node ，其左子节点记为child，执行"右旋"操作。完成右旋后，子树恢复平衡，并且仍然保持二叉搜索树的性质。
如图所示，当节点child有右子节点(记为grand_child)时，需要在右旋中添加一步：将grand_child作为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;
}

9.2 左旋

相应地，如果考虑上述失衡二叉树的"镜像"，则需要执行图所示的"左旋"操作。 同理，如图所示，当节点child有左子节点(记为grand_child)时，需要在左旋中添加一步：将grand_child作为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;
}

9.3 先左旋后右旋

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

9.4 先右旋后左旋

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

9.5 旋转的选择

下图展示的四种失衡情况与上述案例逐个对应，分别需要采用右旋、先左旋后右旋、先右旋后左旋、左旋的操作：
如下表所示，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况：

失衡节点的平衡因子	子节点的平衡因子	应采用的旋转方法
>1 (左偏树)	≥0	右旋
>1 (左偏树)	<0	先左旋后右旋
<−1 (右偏树)	≤0	左旋
<−1 (右偏树)	>0	先右旋后左旋

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

/* 执行旋转操作，使该子树重新恢复平衡 */
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;
}

10. AVL树常用操作

10.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;
}

10.2 删除节点

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

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

/* 递归删除节点(辅助方法) */
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;
}

10.3 查找节点

AVL树的节点查找操作与二叉搜索树一致。

10.4 AVL树典型应用

• 组织和存储大型数据，适用于高频查找、低频增删的场景。
• 用于构建数据库中的索引系统。
• 红黑树也是一种常见的平衡二叉搜索树。相较于AVL树，红黑树的平衡条件更宽松，插入与删除节点所需的旋转操作更少，节点增删操作的平均效率更高。