Update docs for deployment on Vercel.

docs/chapter_searching/binary_search.md

@@ -0,0 +1,154 @@
+---
+comments: true
+---
+
+# 二分查找
+
+「二分查找 Binary Search」利用数据的有序性，通过每轮缩小一半搜索区间来查找目标元素。
+
+使用二分查找有两个前置条件：
+
+- **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间；
+- **二分查找仅适用于数组** ，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
+
+## 算法实现
+
+给定一个长度为 $n$ 的排序数组 `nums` ，元素从小到大排列。数组的索引取值范围为
+
+$$
+0, 1, 2, \cdots, n-1
+$$
+
+使用「区间」来表示这个取值范围的方法主要有两种：
+
+1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；此方法下，区间 $[0, 0]$ 仍包含一个元素；
+2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；此方法下，区间 $[0, 0)$ 为空；
+
+### “双闭区间” 实现
+
+首先，我们先采用 “双闭区间” 的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。
+
+=== "Step 1"
+
+    ![binary_search_step1](binary_search.assets/binary_search_step1.png)
+
+=== "Step 2"
+
+    ![binary_search_step2](binary_search.assets/binary_search_step2.png)
+
+=== "Step 3"
+
+    ![binary_search_step3](binary_search.assets/binary_search_step3.png)
+
+=== "Step 4"
+
+    ![binary_search_step4](binary_search.assets/binary_search_step4.png)
+
+=== "Step 5"
+
+    ![binary_search_step5](binary_search.assets/binary_search_step5.png)
+
+=== "Step 6"
+
+    ![binary_search_step6](binary_search.assets/binary_search_step6.png)
+
+=== "Step 7"
+
+    ![binary_search_step7](binary_search.assets/binary_search_step7.png)
+
+二分查找 “双闭区间” 表示下的代码如下所示。
+
+=== "Java"
+
+    ```java title="binary_search.java"
+    /* 二分查找（双闭区间） */
+    int binarySearch(int[] nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = (i + j) / 2;       // 计算中点索引 m
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else                       // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+### “左闭右开” 实现
+
+当然，我们也可以使用 “左闭右开” 的表示方法，写出相同功能的二分查找代码。
+
+=== "Java"
+
+    ```java title="binary_search.java"
+    /* 二分查找（左闭右开） */
+    int binarySearch1(int[] nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = (i + j) / 2;       // 计算中点索引 m
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else                       // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+### 两种表示对比
+
+对比下来，两种表示的代码写法有以下不同点：
+
+<div class="center-table" markdown>
+
+| 表示方法            | 初始化指针          | 缩小区间                  | 循环终止条件 |
+| ------------------- | ------------------- | ------------------------- | ------------ |
+| 双闭区间 $[0, n-1]$ | $i = 0$ , $j = n-1$ | $i = m + 1$ , $j = m - 1$ | $i > j$      |
+| 左闭右开 $[0, n)$   | $i = 0$ , $j = n$   | $i = m + 1$ , $j = m$     | $i = j$      |
+
+</div>
+
+观察发现，在 “双闭区间” 表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用 “双闭区间” 的写法。**
+
+### 大数越界处理
+
+当数组长度很大时，加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。
+
+```java
+// (i + j) 有可能超出 int 的取值范围
+int m = (i + j) / 2;
+// 更换为此写法则不会越界
+int m = i + (j - i) / 2;
+```
+
+## 复杂度分析
+
+**时间复杂度 $O(\log n)$ ：** 其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
+
+**空间复杂度 $O(1)$ ：** 指针 `i` , `j` 使用常数大小空间。
+
+## 优缺点
+
+二分查找效率很高，体现在：
+
+- **二分查找时间复杂度低。** 对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
+- **二分查找不需要额外空间。** 相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
+
+但并不意味着所有情况下都应使用二分查找，这是因为：
+
+- **二分查找仅适用于有序数据。** 如果输入数据是乱序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
+
+- **二分查找仅适用于数组。** 由于在二分查找中，访问索引是 ”非连续“ 的，因此链表或者基于链表实现的数据结构都无法使用。
+
+- **在小数据量下，线性查找的性能更好。** 在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。

docs/chapter_searching/hashing_search.md

@@ -0,0 +1,60 @@
+---
+comments: true
+---
+
+# 哈希查找
+
+!!! question 
+
+    在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。
+
+「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现 “键 $\rightarrow$ 值” 映射查找，体现着 “以空间换时间” 的算法思想。
+
+## 算法实现
+
+如果我们想要给定数组中的一个目标元素 `target` ，获取该元素的索引，那么可以借助一个哈希表实现查找。
+
+![hash_search_index](hashing_search.assets/hash_search_index.png)
+
+=== "Java"
+
+    ```java title="hashing_search.java"
+    /* 哈希查找（数组） */
+    int hashingSearch(Map<Integer, Integer> map, int target) {
+        // 哈希表的 key: 目标元素，value: 索引
+        // 若哈希表中无此 key ，返回 -1
+        return map.getOrDefault(target, -1);
+    }
+    ```
+
+再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
+
+![hash_search_listnode](hashing_search.assets/hash_search_listnode.png)
+
+=== "Java"
+
+    ```java title="hashing_search.java"
+    /* 哈希查找（链表） */
+    ListNode hashingSearch1(Map<Integer, ListNode> map, int target) {
+        // 哈希表的 key: 目标结点值，value: 结点对象
+        // 若哈希表中无此 key ，返回 -1
+        return map.getOrDefault(target, null);
+    }
+    ```
+
+## 复杂度分析
+
+**时间复杂度：** $O(1)$ ，哈希表的查找操作使用 $O(1)$ 时间。
+
+**空间复杂度：** $O(n)$ ，其中 $n$ 为数组或链表长度。
+
+## 优缺点
+
+在哈希表中，**查找、插入、删除操作的平均时间复杂度都为 $O(1)$** ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。
+
+即使如此，哈希查找仍存在一些问题，在实际应用中，需要根据情况灵活选择方法。
+
+- 辅助哈希表 **需要使用 $O(n)$ 的额外空间**，意味着需要预留更多的计算机内存；
+- 建立和维护哈希表需要时间，因此哈希查找 **不适合高频增删、低频查找的使用场景**；
+- 当哈希冲突严重时，哈希表会退化为链表，**时间复杂度劣化至 $O(n)$** ；
+- **当数据量很小时，线性查找比哈希查找更快**。这是因为计算哈希映射函数可能比遍历一个小型数组更慢；

docs/chapter_searching/linear_search.md

@@ -0,0 +1,60 @@
+---
+comments: true
+---
+
+# 线性查找
+
+「线性查找 Linear Search」是一种最基础的查找方法，其从数据结构的一端开始，依次访问每个元素，直到另一端后停止。
+
+## 算法实现
+
+线性查找实质上就是遍历数据结构 + 判断条件。比如，我们想要在数组 `nums` 中查找目标元素 `target` 的对应索引，那么可以在数组中进行线性查找。
+
+![linear_search](linear_search.assets/linear_search.png)
+
+=== "Java"
+
+    ```java title="linear_search.java"
+    /* 线性查找（数组） */
+    int linearSearch(int[] nums, int target) {
+        // 遍历数组
+        for (int i = 0; i < nums.length; i++) {
+            // 找到目标元素，返回其索引
+            if (nums[i] == target)
+                return i;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
+
+=== "Java"
+
+    ```java title="linear_search.java"
+    /* 线性查找（链表） */
+    ListNode linearSearch(ListNode head, int target) {
+        // 遍历链表
+        while (head != null) {
+            // 找到目标结点，返回之
+            if (head.val == target)
+                return head;
+            head = head.next;
+        }
+        // 未找到目标结点，返回 null
+        return null;
+    }
+    ```
+
+## 复杂度分析
+
+**时间复杂度 $O(n)$ ：** 其中 $n$ 为数组或链表长度。
+
+**空间复杂度 $O(1)$ ：** 无需使用额外空间。
+
+## 优缺点
+
+**线性查找的通用性极佳。** 由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
+
+**线性查找的时间复杂度太高。** 在数据量 $n$ 很大时，查找效率很低。

docs/chapter_searching/summary.md

@@ -0,0 +1,19 @@
+# 小结
+
+- 线性查找是一种最基础的查找方法，通过遍历数据结构 + 判断条件实现查找。
+- 二分查找利用数据的有序性，通过循环不断缩小一半搜索区间来实现查找，其要求输入数据是有序的，并且仅适用于数组或基于数组实现的数据结构。
+- 哈希查找借助哈希表来实现常数阶时间复杂度的查找操作，体现以空间换时间的算法思想。
+
+<p style="text-align:center"> Table. 三种查找方法对比 </p>
+
+<div class="center-table" markdown>
+
+|                                       | 线性查找                 | 二分查找                      | 哈希查找                 |
+| ------------------------------------- | ------------------------ | ----------------------------- | ------------------------ |
+| 适用数据结构                          | 数组、链表               | 数组                          | 数组、链表               |
+| 输入数据要求                          | 无                       | 有序                          | 无                       |
+| 平均时间复杂度</br>查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(1)$ / $O(1)$ / $O(1)$ |
+| 最差时间复杂度</br>查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(n)$ / $O(n)$ / $O(n)$ |
+| 空间复杂度                            | $O(1)$                   | $O(1)$                        | $O(n)$                   |
+
+</div>