Organizing all the code blocks.

2022-12-03 01:31:29 +08:00
parent fec56afd5f
commit 9bd5980a81
21 changed files with 2520 additions and 310 deletions
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -99,6 +99,36 @@ comments: true
        return a + b + c  # 输出数据
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 ## 推算方法

 空间复杂度的推算方法和时间复杂度总体类似，只是从统计 “计算操作数量” 变为统计 “使用空间大小” 。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
@@ -140,6 +170,36 @@ comments: true
            nums = [0] * n  # O(n)
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 **在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。

 === "Java"
@@ -200,6 +260,36 @@ comments: true
        return recur(n - 1)
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 ## 常见类型

 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
@@ -284,6 +374,36 @@ $$
            function()
    ```

+=== "Go"
+
+    ```go title="space_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="space_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="space_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="space_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="space_complexity_types.cs"
+
+    ```
+
 ### 线性阶 $O(n)$

 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
@@ -341,6 +461,36 @@ $$
            mapp[i] = str(i)
    ```

+=== "Go"
+
+    ```go title="space_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="space_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="space_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="space_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="space_complexity_types.cs"
+
+    ```
+
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。

 === "Java"
@@ -375,6 +525,36 @@ $$
        linearRecur(n - 1)
    ```

+=== "Go"
+
+    ```go title="space_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="space_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="space_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="space_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="space_complexity_types.cs"
+
+    ```
+
 ![space_complexity_recursive_linear](space_complexity.assets/space_complexity_recursive_linear.png)

 <p align="center"> Fig. 递归函数产生的线性阶空间复杂度 </p>
@@ -428,6 +608,36 @@ $$
        num_matrix = [[0] * n for _ in range(n)]
    ```

+=== "Go"
+
+    ```go title="space_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="space_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="space_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="space_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="space_complexity_types.cs"
+
+    ```
+
 在以下递归函数中，同时存在 $n$ 个未返回的 `algorihtm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。

 === "Java"
@@ -465,6 +675,36 @@ $$
        return quadratic_recur(n - 1)
    ```

+=== "Go"
+
+    ```go title="space_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="space_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="space_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="space_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="space_complexity_types.cs"
+
+    ```
+
 ![space_complexity_recursive_quadratic](space_complexity.assets/space_complexity_recursive_quadratic.png)

 <p align="center"> Fig. 递归函数产生的平方阶空间复杂度 </p>
@@ -511,6 +751,36 @@ $$
        return root
    ```

+=== "Go"
+
+    ```go title="space_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="space_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="space_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="space_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="space_complexity_types.cs"
+
+    ```
+
 ![space_complexity_exponential](space_complexity.assets/space_complexity_exponential.png)

 <p align="center"> Fig. 满二叉树下的指数阶空间复杂度 </p>
--- a/docs/chapter_computational_complexity/space_time_tradeoff.md
+++ b/docs/chapter_computational_complexity/space_time_tradeoff.md
@@ -20,7 +20,7 @@ comments: true

 === "Java"

-    ```java title="" title="leetcode_two_sum.java"
+    ```java title="leetcode_two_sum.java"
    class SolutionBruteForce {
        public int[] twoSum(int[] nums, int target) {
            int size = nums.length;
@@ -85,6 +85,30 @@ comments: true
    }
    ```

+=== "JavaScript"
+
+    ```js title="leetcode_two_sum.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="leetcode_two_sum.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="leetcode_two_sum.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="leetcode_two_sum.cs"
+
+    ```
+
 ### 方法二：辅助哈希表

 时间复杂度 $O(N)$ ，空间复杂度 $O(N)$ ，属于「空间换时间」。
@@ -93,7 +117,7 @@ comments: true

 === "Java"

-    ```java title="" title="leetcode_two_sum.java"
+    ```java title="leetcode_two_sum.java"
    class SolutionHashMap {
        public int[] twoSum(int[] nums, int target) {
            int size = nums.length;
@@ -163,3 +187,27 @@ comments: true
        return nil
    }
    ```
+
+=== "JavaScript"
+
+    ```js title="leetcode_two_sum.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="leetcode_two_sum.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="leetcode_two_sum.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="leetcode_two_sum.cs"
+
+    ```
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -61,6 +61,36 @@ $$
            print(0)        # 5 ns
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。

 ## 统计时间增长趋势
@@ -131,6 +161,36 @@ $$
            print(0)
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 ![time_complexity_first_example](time_complexity.assets/time_complexity_first_example.png)

 <p align="center"> Fig. 算法 A, B, C 的时间增长趋势 </p>
@@ -192,6 +252,36 @@ $$
    }
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得时间复杂度是线性阶。

 我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号被称为「大 $O$ 记号 Big-$O$ Notation」，代表函数 $T(n)$ 的「渐进上界 asymptotic upper bound」。
@@ -296,6 +386,36 @@ $$
                print(0)
    ```

+=== "Go"
+
+    ```go title=""
+
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+
+    ```
+
+=== "C"
+
+    ```c title=""
+
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+
+    ```
+
 ### 2. 判断渐进上界

 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将处于主导作用，其它项的影响都可以被忽略。
@@ -341,7 +461,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 常数阶 */
    int constant(int n) {
        int count = 0;
@@ -377,13 +497,43 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ### 线性阶 $O(n)$

 线性阶的操作数量相对输入数据大小成线性级别增长。线性阶常出现于单层循环。

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 线性阶 */
    int linear(int n) {
        int count = 0;
@@ -416,6 +566,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 「遍历数组」和「遍历链表」等操作，时间复杂度都为 $O(n)$ ，其中 $n$ 为数组或链表的长度。

 !!! tip
@@ -424,7 +604,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 线性阶（遍历数组） */
    int arrayTraversal(int[] nums) {
        int count = 0;
@@ -462,13 +642,43 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ### 平方阶 $O(n^2)$

 平方阶的操作数量相对输入数据大小成平方级别增长。平方阶常出现于嵌套循环，外层循环和内层循环都为 $O(n)$ ，总体为 $O(n^2)$ 。

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 平方阶 */
    int quadratic(int n) {
        int count = 0;
@@ -511,6 +721,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ![time_complexity_constant_linear_quadratic](time_complexity.assets/time_complexity_constant_linear_quadratic.png)

 <p align="center"> Fig. 常数阶、线性阶、平方阶的时间复杂度 </p>
@@ -523,7 +763,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 平方阶（冒泡排序） */
    int bubbleSort(int[] nums) {
        int count = 0;  // 计数器
@@ -586,6 +826,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ### 指数阶 $O(2^n)$

 !!! note
@@ -596,7 +866,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 指数阶（循环实现） */
    int exponential(int n) {
        int count = 0, base = 1;
@@ -645,6 +915,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ![time_complexity_exponential](time_complexity.assets/time_complexity_exponential.png)

 <p align="center"> Fig. 指数阶的时间复杂度 </p>
@@ -653,7 +953,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 指数阶（递归实现） */
    int expRecur(int n) {
        if (n == 1) return 1;
@@ -680,6 +980,36 @@ $$
        return exp_recur(n - 1) + exp_recur(n - 1) + 1
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ### 对数阶 $O(\log n)$

 对数阶与指数阶正好相反，后者反映 “每轮增加到两倍的情况” ，而前者反映 “每轮缩减到一半的情况” 。对数阶仅次于常数阶，时间增长的很慢，是理想的时间复杂度。
@@ -690,7 +1020,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 对数阶（循环实现） */
    int logarithmic(float n) {
        int count = 0;
@@ -728,6 +1058,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ![time_complexity_logarithmic](time_complexity.assets/time_complexity_logarithmic.png)

 <p align="center"> Fig. 对数阶的时间复杂度 </p>
@@ -736,7 +1096,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 对数阶（递归实现） */
    int logRecur(float n) {
        if (n <= 1) return 0;
@@ -763,6 +1123,36 @@ $$
        return log_recur(n / 2) + 1
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ### 线性对数阶 $O(n \log n)$

 线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
@@ -771,7 +1161,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 线性对数阶 */
    int linearLogRecur(float n) {
        if (n <= 1) return 1;
@@ -812,6 +1202,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ![time_complexity_logarithmic_linear](time_complexity.assets/time_complexity_logarithmic_linear.png)

 <p align="center"> Fig. 线性对数阶的时间复杂度 </p>
@@ -828,7 +1248,7 @@ $$

 === "Java"

-    ```java title="" title="time_complexity_types.java"
+    ```java title="time_complexity_types.java"
    /* 阶乘阶（递归实现） */
    int factorialRecur(int n) {
        if (n == 0) return 1;
@@ -869,6 +1289,36 @@ $$
        return count
    ```

+=== "Go"
+
+    ```go title="time_complexity_types.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="time_complexity_types.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="time_complexity_types.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="time_complexity_types.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="time_complexity_types.cs"
+
+    ```
+
 ![time_complexity_factorial](time_complexity.assets/time_complexity_factorial.png)

 <p align="center"> Fig. 阶乘阶的时间复杂度 </p>
@@ -884,7 +1334,7 @@ $$

 === "Java"

-    ```java title="" title="worst_best_time_complexity.java"
+    ```java title="worst_best_time_complexity.java"
    public class worst_best_time_complexity {
        /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
        static int[] randomNumbers(int n) {
@@ -994,6 +1444,36 @@ $$
            print("数字 1 的索引为", index)
    ```

+=== "Go"
+
+    ```go title="worst_best_time_complexity.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="worst_best_time_complexity.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="worst_best_time_complexity.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="worst_best_time_complexity.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="worst_best_time_complexity.cs"
+
+    ```
+
 !!! tip

    我们在实际应用中很少使用「最佳时间复杂度」，因为往往只有很小概率下才能达到，会带来一定的误导性。反之，「最差时间复杂度」最为实用，因为它给出了一个 “效率安全值” ，让我们可以放心地使用算法。