Release Rust code to documents. (#656)

docs/chapter_computational_complexity/space_complexity.md

@@ -280,6 +280,12 @@
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 ## 推算方法
 
 空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
@@ -412,6 +418,12 @@
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 **在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
 
 === "Java"
@@ -627,6 +639,12 @@
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 ## 常见类型
 
 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
@@ -716,6 +734,12 @@ $$
     [class]{}-[func]{constant}
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    [class]{}-[func]{constant}
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
@@ -788,6 +812,12 @@ $$
     [class]{}-[func]{linear}
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    [class]{}-[func]{linear}
+    ```
+
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
 
 === "Java"
@@ -856,6 +886,12 @@ $$
     [class]{}-[func]{linearRecur}
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    [class]{}-[func]{linear_recur}
+    ```
+
 ![递归函数产生的线性阶空间复杂度](space_complexity.assets/space_complexity_recursive_linear.png)
 
 ### 平方阶 $O(n^2)$
@@ -928,6 +964,12 @@ $$
     [class]{}-[func]{quadratic}
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    [class]{}-[func]{quadratic}
+    ```
+
 在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体占用 $O(n^2)$ 空间。
 
 === "Java"
@@ -996,6 +1038,12 @@ $$
     [class]{}-[func]{quadraticRecur}
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    [class]{}-[func]{quadratic_recur}
+    ```
+
 ![递归函数产生的平方阶空间复杂度](space_complexity.assets/space_complexity_recursive_quadratic.png)
 
 ### 指数阶 $O(2^n)$
@@ -1068,6 +1116,12 @@ $$
     [class]{}-[func]{buildTree}
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    [class]{}-[func]{build_tree}
+    ```
+
 ![满二叉树产生的指数阶空间复杂度](space_complexity.assets/space_complexity_exponential.png)
 
 ### 对数阶 $O(\log n)$

docs/chapter_computational_complexity/time_complexity.md

@@ -168,6 +168,12 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 然而实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
 
 ## 统计时间增长趋势
@@ -394,6 +400,12 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 ![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
 
 相较于直接统计算法运行时间，时间复杂度分析有哪些优势和局限性呢？
@@ -556,6 +568,12 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得出时间复杂度是线性阶。
 
 我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
@@ -795,6 +813,12 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 ### 第二步：判断渐近上界
 
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
@@ -902,6 +926,12 @@ $$
     [class]{}-[func]{constant}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{constant}
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。
@@ -972,6 +1002,12 @@ $$
     [class]{}-[func]{linear}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{linear}
+    ```
+
 遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
 
 !!! question "如何确定输入数据大小 $n$ ？"
@@ -1044,6 +1080,12 @@ $$
     [class]{}-[func]{arrayTraversal}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{array_traversal}
+    ```
+
 ### 平方阶 $O(n^2)$
 
 平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
@@ -1114,6 +1156,12 @@ $$
     [class]{}-[func]{quadratic}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{quadratic}
+    ```
+
 ![常数阶、线性阶、平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
 
 以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。
@@ -1188,6 +1236,12 @@ $$
     [class]{}-[func]{bubbleSort}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{bubble_sort}
+    ```
+
 ### 指数阶 $O(2^n)$
 
 !!! note
@@ -1262,6 +1316,12 @@ $$
     [class]{}-[func]{exponential}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{exponential}
+    ```
+
 ![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)
 
 在实际算法中，指数阶常出现于递归函数。例如以下代码，不断地一分为二，经过 $n$ 次分裂后停止。
@@ -1332,6 +1392,12 @@ $$
     [class]{}-[func]{expRecur}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{exp_recur}
+    ```
+
 ### 对数阶 $O(\log n)$
 
 与指数阶相反，对数阶反映了“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长缓慢，是理想的时间复杂度。
@@ -1406,6 +1472,12 @@ $$
     [class]{}-[func]{logarithmic}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{logarithmic}
+    ```
+
 ![对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic.png)
 
 与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。
@@ -1476,6 +1548,12 @@ $$
     [class]{}-[func]{logRecur}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{log_recur}
+    ```
+
 ### 线性对数阶 $O(n \log n)$
 
 线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
@@ -1548,6 +1626,12 @@ $$
     [class]{}-[func]{linearLogRecur}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{linear_log_recur}
+    ```
+
 ![线性对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic_linear.png)
 
 ### 阶乘阶 $O(n!)$
@@ -1626,6 +1710,12 @@ $$
     [class]{}-[func]{factorialRecur}
     ```
 
+=== "Rust"
+
+    ```rust title="time_complexity.rs"
+    [class]{}-[func]{factorial_recur}
+    ```
+
 ![阶乘阶的时间复杂度](time_complexity.assets/time_complexity_factorial.png)
 
 ## 最差、最佳、平均时间复杂度
@@ -1744,6 +1834,14 @@ $$
     [class]{}-[func]{findOne}
     ```
 
+=== "Rust"
+
+    ```rust title="worst_best_time_complexity.rs"
+    [class]{}-[func]{random_numbers}
+
+    [class]{}-[func]{find_one}
+    ```
+
 !!! tip
 
     实际应用中我们很少使用「最佳时间复杂度」，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。相反，「最差时间复杂度」更为实用，因为它给出了一个“效率安全值”，让我们可以放心地使用算法。