build

chapter_computational_complexity/space_complexity.md

@@ -26,7 +26,7 @@ comments: true
 
 ![算法使用的相关空间](space_complexity.assets/space_types.png)
 
-<p align="center"> 图：算法使用的相关空间 </p>
+<p align="center"> 图 2-9 &nbsp; 算法使用的相关空间 </p>
 
 === "Java"
 
@@ -658,7 +658,7 @@ comments: true
 
 ## 2.3.3 &nbsp; 常见类型
 
-设输入数据大小为 $n$ ，下图展示了常见的空间复杂度类型（从低到高排列）。
+设输入数据大小为 $n$ ，图 2-10 展示了常见的空间复杂度类型（从低到高排列）。
 
 $$
 \begin{aligned}
@@ -669,7 +669,7 @@ $$
 
 ![常见的空间复杂度类型](space_complexity.assets/space_complexity_common_types.png)
 
-<p align="center"> 图：常见的空间复杂度类型 </p>
+<p align="center"> 图 2-10 &nbsp; 常见的空间复杂度类型 </p>
 
 !!! tip
 
@@ -1274,7 +1274,7 @@ $$
     }
     ```
 
-如下图所示，此函数的递归深度为 $n$ ，即同时存在 $n$ 个未返回的 `linear_recur()` 函数，使用 $O(n)$ 大小的栈帧空间：
+如图 2-11 所示，此函数的递归深度为 $n$ ，即同时存在 $n$ 个未返回的 `linear_recur()` 函数，使用 $O(n)$ 大小的栈帧空间：
 
 === "Java"
 
@@ -1417,7 +1417,7 @@ $$
 
 ![递归函数产生的线性阶空间复杂度](space_complexity.assets/space_complexity_recursive_linear.png)
 
-<p align="center"> 图：递归函数产生的线性阶空间复杂度 </p>
+<p align="center"> 图 2-11 &nbsp; 递归函数产生的线性阶空间复杂度 </p>
 
 ### 3. &nbsp; 平方阶 $O(n^2)$
 
@@ -1635,7 +1635,7 @@ $$
     }
     ```
 
-如下图所示，该函数的递归深度为 $n$ ，在每个递归函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $n / 2$ ，因此总体占用 $O(n^2)$ 空间：
+如图 2-12 所示，该函数的递归深度为 $n$ ，在每个递归函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $n / 2$ ，因此总体占用 $O(n^2)$ 空间：
 
 === "Java"
 
@@ -1796,11 +1796,11 @@ $$
 
 ![递归函数产生的平方阶空间复杂度](space_complexity.assets/space_complexity_recursive_quadratic.png)
 
-<p align="center"> 图：递归函数产生的平方阶空间复杂度 </p>
+<p align="center"> 图 2-12 &nbsp; 递归函数产生的平方阶空间复杂度 </p>
 
 ### 4. &nbsp; 指数阶 $O(2^n)$
 
-指数阶常见于二叉树。观察下图，高度为 $n$ 的“满二叉树”的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
+指数阶常见于二叉树。观察图 2-13 ，高度为 $n$ 的“满二叉树”的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
 
 === "Java"
 
@@ -1968,7 +1968,7 @@ $$
 
 ![满二叉树产生的指数阶空间复杂度](space_complexity.assets/space_complexity_exponential.png)
 
-<p align="center"> 图：满二叉树产生的指数阶空间复杂度 </p>
+<p align="center"> 图 2-13 &nbsp; 满二叉树产生的指数阶空间复杂度 </p>
 
 ### 5. &nbsp; 对数阶 $O(\log n)$
 

chapter_computational_complexity/time_complexity.md

@@ -430,7 +430,7 @@ $$
     }
     ```
 
-下图展示了以上三个算法函数的时间复杂度。
+图 2-1 展示了以上三个算法函数的时间复杂度。
 
 - 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为“常数阶”。
 - 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。
@@ -438,7 +438,7 @@ $$
 
 ![算法 A 、B 和 C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
 
-<p align="center"> 图：算法 A 、B 和 C 的时间增长趋势 </p>
+<p align="center"> 图 2-1 &nbsp; 算法 A 、B 和 C 的时间增长趋势 </p>
 
 相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
 
@@ -632,11 +632,11 @@ $T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因
     T(n) = O(f(n))
     $$
 
-如下图所示，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
+如图 2-2 所示，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
 
 ![函数的渐近上界](time_complexity.assets/asymptotic_upper_bound.png)
 
-<p align="center"> 图：函数的渐近上界 </p>
+<p align="center"> 图 2-2 &nbsp; 函数的渐近上界 </p>
 
 ## 2.2.3 &nbsp; 推算方法
 
@@ -879,9 +879,9 @@ $$
 
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
 
-下表展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
+表 2-1 展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
 
-<p align="center"> 表：不同操作数量对应的时间复杂度 </p>
+<p align="center"> 表 2-1 &nbsp; 不同操作数量对应的时间复杂度 </p>
 
 <div class="center-table" markdown>
 
@@ -897,7 +897,7 @@ $$
 
 ## 2.2.4 &nbsp; 常见类型
 
-设输入数据大小为 $n$ ，常见的时间复杂度类型如下图所示（按照从低到高的顺序排列）。
+设输入数据大小为 $n$ ，常见的时间复杂度类型如图 2-3 所示（按照从低到高的顺序排列）。
 
 $$
 \begin{aligned}
@@ -908,7 +908,7 @@ $$
 
 ![常见的时间复杂度类型](time_complexity.assets/time_complexity_common_types.png)
 
-<p align="center"> 图：常见的时间复杂度类型 </p>
+<p align="center"> 图 2-3 &nbsp; 常见的时间复杂度类型 </p>
 
 !!! tip
 
@@ -1600,11 +1600,11 @@ $$
     }
     ```
 
-下图对比了常数阶、线性阶和平方阶三种时间复杂度。
+图 2-4 对比了常数阶、线性阶和平方阶三种时间复杂度。
 
 ![常数阶、线性阶和平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
 
-<p align="center"> 图：常数阶、线性阶和平方阶的时间复杂度 </p>
+<p align="center"> 图 2-4 &nbsp; 常数阶、线性阶和平方阶的时间复杂度 </p>
 
 以冒泡排序为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \dots, 2, 1$ 次，平均为 $n / 2$ 次，因此时间复杂度为 $O((n - 1) n / 2) = O(n^2)$ 。
 
@@ -1884,7 +1884,7 @@ $$
 
 生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
 
-以下代码和图模拟了细胞分裂的过程，时间复杂度为 $O(2^n)$ 。
+图 2-5 和以下代码模拟了细胞分裂的过程，时间复杂度为 $O(2^n)$ 。
 
 === "Java"
 
@@ -2110,7 +2110,7 @@ $$
 
 ![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)
 
-<p align="center"> 图：指数阶的时间复杂度 </p>
+<p align="center"> 图 2-5 &nbsp; 指数阶的时间复杂度 </p>
 
 在实际算法中，指数阶常出现于递归函数中。例如在以下代码中，其递归地一分为二，经过 $n$ 次分裂后停止：
 
@@ -2249,7 +2249,7 @@ $$
 
 与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
 
-以下代码和图模拟了“每轮缩减到一半”的过程，时间复杂度为 $O(\log_2 n)$ ，简记为 $O(\log n)$ 。
+图 2-6 和以下代码模拟了“每轮缩减到一半”的过程，时间复杂度为 $O(\log_2 n)$ ，简记为 $O(\log n)$ 。
 
 === "Java"
 
@@ -2422,7 +2422,7 @@ $$
 
 ![对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic.png)
 
-<p align="center"> 图：对数阶的时间复杂度 </p>
+<p align="center"> 图 2-6 &nbsp; 对数阶的时间复杂度 </p>
 
 与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 $\log_2 n$ 的递归树：
 
@@ -2753,11 +2753,11 @@ $$
     }
     ```
 
-下图展示了线性对数阶的生成方式。二叉树的每一层的操作总数都为 $n$ ，树共有 $\log_2 n + 1$ 层，因此时间复杂度为 $O(n \log n)$ 。
+图 2-7 展示了线性对数阶的生成方式。二叉树的每一层的操作总数都为 $n$ ，树共有 $\log_2 n + 1$ 层，因此时间复杂度为 $O(n \log n)$ 。
 
 ![线性对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic_linear.png)
 
-<p align="center"> 图：线性对数阶的时间复杂度 </p>
+<p align="center"> 图 2-7 &nbsp; 线性对数阶的时间复杂度 </p>
 
 主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
 
@@ -2769,7 +2769,7 @@ $$
 n! = n \times (n - 1) \times (n - 2) \times \dots \times 2 \times 1
 $$
 
-阶乘通常使用递归实现。如下图和以下代码所示，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
+阶乘通常使用递归实现。如图 2-8 和以下代码所示，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
 
 === "Java"
 
@@ -2961,7 +2961,7 @@ $$
 
 ![阶乘阶的时间复杂度](time_complexity.assets/time_complexity_factorial.png)
 
-<p align="center"> 图：阶乘阶的时间复杂度 </p>
+<p align="center"> 图 2-8 &nbsp; 阶乘阶的时间复杂度 </p>
 
 请注意，因为当 $n \geq 4$ 时恒有 $n! > 2^n$ ，所以阶乘阶比指数阶增长得更快，在 $n$ 较大时也是不可接受的。