Update docs for deployment on Vercel.

docs/chapter_tree/binary_search_tree.md

@@ -0,0 +1,236 @@
+---
+comments: true
+---
+
+# 二叉搜索树
+
+「二叉搜索树 Binary Search Tree」满足以下条件：
+
+1. 对于根结点，左子树中所有结点的值 $<$ 根结点的值 $<$ 右子树中所有结点的值；
+2. 任意结点的左子树和右子树也是二叉搜索树，即也满足条件 `1.` ；
+
+![binary_search_tree](binary_search_tree.assets/binary_search_tree.png)
+
+## 二叉搜索树的操作
+
+### 查找结点
+
+给定目标结点值 `num` ，可以根据二叉搜索树的性质来查找。我们声明一个结点 `cur` ，从二叉树的根结点 `root` 出发，循环比较结点值 `cur.val` 和 `num` 之间的大小关系
+
+- 若 `cur.val < val` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
+- 若 `cur.val > val` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
+- 若 `cur.val = val` ，说明找到目标结点，跳出循环并返回该结点即可；
+
+=== "Step 1"
+
+    ![bst_search_1](binary_search_tree.assets/bst_search_1.png)
+
+=== "Step 2"
+
+    ![bst_search_2](binary_search_tree.assets/bst_search_2.png)
+
+=== "Step 3"
+
+    ![bst_search_3](binary_search_tree.assets/bst_search_3.png)
+
+=== "Step 4"
+
+    ![bst_search_4](binary_search_tree.assets/bst_search_4.png)
+
+二叉搜索树的查找操作和二分查找算法如出一辙，也是在每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用 $O(\log n)$ 时间。
+
+=== "Java"
+
+    ```java title="binary_search_tree.java"
+    /* 查找结点 */
+    TreeNode search(int num) {
+        TreeNode cur = root;
+        // 循环查找，越过叶结点后跳出
+        while (cur != null) {
+            // 目标结点在 root 的右子树中
+            if (cur.val < num) cur = cur.right;
+            // 目标结点在 root 的左子树中
+            else if (cur.val > num) cur = cur.left;
+            // 找到目标结点，跳出循环
+            else break;
+        }
+        // 返回目标结点
+        return cur;
+    }
+    ```
+
+### 插入结点
+
+给定一个待插入元素 `num` ，为了保持二叉搜索树 “左子树 < 根结点 < 右子树” 的性质，插入操作分为两步：
+
+1. **查找插入位置：** 与查找操作类似，我们从根结点出发，根据当前节点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
+
+2. **在该位置插入结点：** 初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
+
+二叉搜索树不允许存在重复节点，否则将会违背其定义。因此若待插入结点在树中已经存在，则不执行插入，直接返回即可。
+
+![bst_insert](binary_search_tree.assets/bst_insert.png)
+
+=== "Java"
+
+    ```java title="binary_search_tree.java"
+    /* 插入结点 */
+    TreeNode insert(int num) {
+        // 若树为空，直接提前返回
+        if (root == null) return null;
+        TreeNode cur = root, pre = null;
+        // 循环查找，越过叶结点后跳出
+        while (cur != null) {
+            // 找到重复结点，直接返回
+            if (cur.val == num) return null;
+            pre = cur;
+            // 插入位置在 root 的右子树中
+            if (cur.val < num) cur = cur.right;
+            // 插入位置在 root 的左子树中
+            else cur = cur.left;
+        }
+        // 插入结点 val
+        TreeNode node = new TreeNode(num);
+        if (pre.val < num) pre.right = node;
+        else pre.left = node;
+        return node;
+    }
+    ```
+
+为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
+
+与查找结点相同，插入结点使用 $O(\log n)$ 时间。
+
+### 删除结点
+
+与插入结点一样，我们需要在删除操作后维持二叉搜索树的 “左子树 < 根结点 < 右子树” 的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
+
+**待删除结点的子结点数量 $= 0$ 。** 表明待删除结点是叶结点，直接删除即可。
+
+![bst_remove_case1](binary_search_tree.assets/bst_remove_case1.png)
+
+**待删除结点的子结点数量 $= 1$ 。** 将待删除结点替换为其子结点。
+
+![bst_remove_case2](binary_search_tree.assets/bst_remove_case2.png)
+
+**待删除结点的子结点数量 $= 2$ 。** 删除操作分为三步：
+
+1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
+2. 在树中递归删除结点 `nex` ；
+3. 使用 `nex` 替换待删除结点；
+
+=== "Step 1"
+
+    ![bst_remove_case3_1](binary_search_tree.assets/bst_remove_case3_1.png)
+
+=== "Step 2"
+
+    ![bst_remove_case3_2](binary_search_tree.assets/bst_remove_case3_2.png)
+
+=== "Step 3"
+
+    ![bst_remove_case3_3](binary_search_tree.assets/bst_remove_case3_3.png)
+
+=== "Step 4"
+
+    ![bst_remove_case3_4](binary_search_tree.assets/bst_remove_case3_4.png)
+
+删除结点操作也使用 $O(\log n)$ 时间，其中查找待删除结点 $O(\log n)$ ，获取中序遍历后继结点 $O(\log n)$ 。
+
+=== "Java"
+
+    ```java title="binary_search_tree.java"
+    /* 删除结点 */
+    TreeNode remove(int num) {
+        // 若树为空，直接提前返回
+        if (root == null) return null;
+        TreeNode cur = root, pre = null;
+        // 循环查找，越过叶结点后跳出
+        while (cur != null) {
+            // 找到待删除结点，跳出循环
+            if (cur.val == num) break;
+            pre = cur;
+            // 待删除结点在 root 的右子树中
+            if (cur.val < num) cur = cur.right;
+            // 待删除结点在 root 的左子树中
+            else cur = cur.left;
+        }
+        // 若无待删除结点，则直接返回
+        if (cur == null) return null;
+        // 子结点数量 = 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 (pre.left == cur) pre.left = child;
+            else pre.right = child;
+        }
+        // 子结点数量 = 2
+        else {
+            // 获取中序遍历中 cur 的下一个结点
+            TreeNode nex = min(cur.right);
+            int tmp = nex.val;
+            // 递归删除结点 nex
+            remove(nex.val);
+            // 将 nex 的值复制给 cur
+            cur.val = tmp;
+        }
+        return cur;
+    }
+    /* 获取最小结点 */
+    TreeNode min(TreeNode root) {
+        if (root == null) return root;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (root.left != null) {
+            root = root.left;
+        }
+        return root;
+    }
+    ```
+
+## 二叉搜索树的优势
+
+假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：
+
+- **查找元素：** 由于数组是乱序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
+- **插入元素：** 只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
+- **删除元素：** 先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
+- **获取最小 / 最大元素：** 需要遍历数组来确定，使用 $O(1)$ 时间；
+
+为了得到先验信息，我们也可以预先将数组元素进行排序，得到一个「排序数组」，此时操作效率为：
+
+- **查找元素：** 由于数组已排序，可以使用二分查找，使用 $O(\log n)$ 时间；
+- **插入元素：** 为了保持数组是有序的，需插入到数组某位置，平均使用 $O(n)$ 时间；
+- **删除元素：** 与乱序数组中的情况相同，使用 $O(n)$ 时间；
+- **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
+
+观察发现，乱序数组和排序数组中的各类操作的时间复杂度是 “偏科” 的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
+
+<div class="center-table" markdown>
+
+|                     | 乱序数组 | 排序数组    | 二叉搜索树  |
+| ------------------- | -------- | ----------- | ----------- |
+| 查找指定元素        | $O(n)$   | $O(\log n)$ | $O(\log n)$ |
+| 插入元素            | $O(1)$   | $O(n)$      | $O(\log n)$ |
+| 删除元素            | $O(n)$   | $O(n)$      | $O(\log n)$ |
+| 获取最小 / 最大元素 | $O(n)$   | $O(1)$      | $O(\log n)$ |
+
+</div>
+
+## 二叉搜索树的退化
+
+二叉搜索树的理想状态是「完美二叉树」，我们称这样的二叉树是 “平衡” 的，此时可以在 $\log n$ 轮循环内查找任意结点。
+
+如果我们动态地在二叉搜索树中插入与删除结点，**则可能导致二叉树退化为链表**，此时各种操作的时间复杂度也退化之 $O(n)$ 。
+
+!!! note
+
+    在实际应用中，如何保持二叉搜索树的平衡，也是一个需要重要考虑的问题。
+
+![bst_degradation](binary_search_tree.assets/bst_degradation.png)
+
+## 二叉搜索树常见应用
+
+- 系统中的多级索引，高效查找、插入、删除操作。
+- 各种搜索算法的底层数据结构。
+- 存储数据流，保持其已排序。

docs/chapter_tree/binary_tree.md

@@ -0,0 +1,196 @@
+---
+comments: true
+---
+
+# 二叉树
+
+「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着 “一分为二” 的分治逻辑。类似于链表，二叉树也是以结点为单位存储的，结点包含「值」和两个「指针」。
+
+=== "Java"
+
+    ```java
+    /* 链表结点类 */
+    class TreeNode {
+        int val;         // 结点值
+        TreeNode left;   // 左子结点指针
+        TreeNode right;  // 右子结点指针
+        TreeNode(int x) { val = x; }
+    }
+    ```
+
+结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
+
+![binary_tree_definition](binary_tree.assets/binary_tree_definition.png)
+
+<p style="text-align:center"> Fig. 子结点与子树 </p>
+
+需要注意，父结点、子结点、子树是可以向下递推的。例如，如果将上图的「结点 2」看作父结点，那么其左子节点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
+
+## 二叉树常见术语
+
+「根结点 Root Node」：二叉树最顶层的结点，其没有父结点；
+
+「叶结点 Leaf Node」：没有子结点的结点，其两个指针都指向 $\text{null}$ ；
+
+结点「度 Degree」：结点的子结点数量，二叉树中度的范围是 0, 1, 2 ；
+
+结点「深度 Depth」 ：根结点到该结点的层数；
+
+结点「高度 Height」：最远叶结点到该结点的层数；
+
+二叉树「高度」：二叉树中根结点到最远叶结点的层数；
+
+![binary_tree_terminology](binary_tree.assets/binary_tree_terminology.png)
+
+<p style="text-align:center"> Fig. 二叉树的常见术语 </p>
+
+## 二叉树最佳和最差结构
+
+当二叉树的每层的结点都被填满时，达到「完美二叉树」；而当所有结点都偏向一边时，二叉树退化为「链表」。
+
+![binary_tree_corner_cases](binary_tree.assets/binary_tree_corner_cases.png)
+
+<p style="text-align:center"> Fig. 二叉树的最佳和最差结构 </p>
+
+在最佳和最差结构下，二叉树的结点数量和高度等性质达到最大（最小）值。
+
+<div class="center-table" markdown>
+
+|                               | 完美二叉树 | 链表           |
+| ----------------------------- | ---------- | -------------- |
+| 二叉树第 $i$ 层的结点数量     | $2^{i-1}$  | $1$            |
+| 高度为 $h$ 的二叉树的结点总数 | $2^h - 1$  | $h$            |
+| 结点总数为 $n$ 的二叉树的高度 | $n$        | $\log_2 n + 1$ |
+
+</div>
+
+## 二叉树基本操作
+
+**初始化二叉树。** 与链表类似，先初始化结点，再构建引用指向（即指针）。
+
+=== "Java"
+
+    ```java title="binary_tree.java"
+    // 初始化结点
+    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;
+    ```
+
+**插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
+
+![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)
+
+<p style="text-align:center"> Fig. 在二叉树中插入与删除结点 </p>
+
+```java title="binary_tree.java"
+TreeNode P = new TreeNode(0);
+// 在 n1 -> n2 中间插入结点 P
+n1.left = P;
+P.left = n2;
+// 删除结点 P
+n1.left = n2;
+```
+
+!!! note
+
+    插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。
+
+## 二叉树遍历
+
+非线性数据结构的遍历操作比线性数据结构更加复杂，往往需要使用搜索算法来实现。常见的二叉树遍历方式有层序遍历、前序遍历、中序遍历、后序遍历。
+
+### 层序遍历
+
+「层序遍历 Hierarchical-Order Traversal」从顶至底、一层一层地遍历二叉树，并在每层中按照从左到右的顺序访问结点。
+
+层序遍历本质上是「广度优先搜索 Breadth-First Traversal」，其体现着一种 “一圈一圈向外” 的层进遍历方式。
+
+![binary_tree_bfs](binary_tree.assets/binary_tree_bfs.png)
+
+<p style="text-align:center"> Fig. 二叉树的层序遍历 </p>
+
+广度优先遍历一般借助「队列」来实现。队列的规则是 “先进先出” ，广度优先遍历的规则是 ”一层层平推“ ，两者背后的思想是一致的。
+
+=== "Java"
+
+    ```java title="binary_tree_bfs.java"
+    /* 层序遍历 */
+    List<Integer> hierOrder(TreeNode root) {
+        // 初始化队列，加入根结点
+        Queue<TreeNode> queue = new LinkedList<>() {{ 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;
+    }
+    ```
+
+### 前序、中序、后序遍历
+
+相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种 “先走到尽头，再回头继续” 的回溯遍历方式。
+
+如下图所示，左侧是深度优先遍历的的示意图，右上方是对应的递归实现代码。深度优先遍历就像是绕着整个二叉树的外围 “走” 一圈，走的过程中，在每个结点都会遇到三个位置，分别对应前序遍历、中序遍历、后序遍历。
+
+![binary_tree_dfs](binary_tree.assets/binary_tree_dfs.png)
+
+<p style="text-align:center"> Fig. 二叉树的前 / 中 / 后序遍历 </p>
+
+<div class="center-table" markdown>
+
+| 位置       | 含义                                 | 此处访问结点时对应            |
+| ---------- | ------------------------------------ | ----------------------------- |
+| 橙色圆圈处 | 刚进入此结点，即将访问该结点的左子树 | 前序遍历 Pre-Order Traversal  |
+| 蓝色圆圈处 | 已访问完左子树，即将访问右子树       | 中序遍历 In-Order Traversal   |
+| 紫色圆圈处 | 已访问完左子树和右子树，即将返回     | 后序遍历 Post-Order Traversal |
+
+</div>
+
+=== "Java"
+
+    ```java title="binary_tree_dfs.java"
+    /* 前序遍历 */
+    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);
+    }
+    ```
+
+!!! note
+
+    使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。

docs/chapter_tree/binary_tree_types.md

@@ -0,0 +1,41 @@
+---
+comments: true
+---
+
+# 常见二叉树类型
+
+## 完美二叉树
+
+「完美二叉树 Perfect Binary Tree」，其所有层的结点都被完全填满。
+
+!!! tip
+
+    在中文社区中，完美二叉树常被称为「满二叉树」，请注意与完满二叉树区分。
+
+![perfect_binary_tree](binary_tree_types.assets/perfect_binary_tree.png)
+
+完美二叉树的性质有：
+
+- 若树高度 $= h$ ，则结点总数 $= 2^h$ ；
+
+## 完全二叉树
+
+「完全二叉树 Complete Binary Tree」只有最底层的结点未被填满，且最底层结点都尽量靠左填充。
+
+![complete_binary_tree](binary_tree_types.assets/complete_binary_tree.png)
+
+完全二叉树有一个很好的性质，可以用「数组」来表示。
+
+- 
+
+## 完满二叉树
+
+「完满二叉树 Full Binary Tree」除了叶结点之外，其余所有结点都有两个子结点。
+
+![full_binary_tree](binary_tree_types.assets/full_binary_tree.png)
+
+## 平衡二叉树
+
+**「平衡二叉树 Balanced Binary Tree」，又称「AVL 树」** ，其任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。
+
+![balanced_binary_tree](binary_tree_types.assets/balanced_binary_tree.png)

docs/chapter_tree/summary.md

@@ -0,0 +1,6 @@
+---
+comments: true
+---
+
+# 小结
+