build

chapter_computational_complexity/time_complexity.md

@@ -869,7 +869,16 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{constant}
+    /* 常数阶 */
+    int constant(int n) {
+        int count = 0;
+        int size = 100000;
+        int i = 0;
+        for (int i = 0; i < size; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -993,7 +1002,14 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{linear}
+    /* 线性阶 */
+    int linear(int n) {
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1127,7 +1143,15 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{arrayTraversal}
+    /* 线性阶（遍历数组） */
+    int arrayTraversal(int *nums, int n) {
+        int count = 0;
+        // 循环次数与数组长度成正比
+        for (int i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1274,7 +1298,17 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{quadratic}
+    /* 平方阶 */
+    int quadratic(int n) {
+        int count = 0;
+        // 循环次数与数组长度成平方关系
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                count++;
+            }
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1477,7 +1511,24 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{bubbleSort}
+    /* 平方阶（冒泡排序） */
+    int bubbleSort(int *nums, int n) {
+        int count = 0; // 计数器
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (int i = n - 1; i > 0; i--) {
+            // 内循环：冒泡操作
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    count += 3; // 元素交换包含 3 个单元操作
+                }
+            }
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1674,7 +1725,20 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{exponential}
+    /* 指数阶（循环实现） */
+    int exponential(int n) {
+        int count = 0;
+        int bas = 1;
+        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < bas; j++) {
+                count++;
+            }
+            bas *= 2;
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count;
+    }
     ```
 
 === "C#"
@@ -1811,7 +1875,12 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{expRecur}
+    /* 指数阶（递归实现） */
+    int expRecur(int n) {
+        if (n == 1)
+            return 1;
+        return expRecur(n - 1) + expRecur(n - 1) + 1;
+    }
     ```
 
 === "C#"
@@ -1940,7 +2009,15 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{logarithmic}
+    /* 对数阶（循环实现） */
+    int logarithmic(float n) {
+        int count = 0;
+        while (n > 1) {
+            n = n / 2;
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -2063,7 +2140,12 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{logRecur}
+    /* 对数阶（递归实现） */
+    int logRecur(float n) {
+        if (n <= 1)
+            return 0;
+        return logRecur(n / 2) + 1;
+    }
     ```
 
 === "C#"
@@ -2197,7 +2279,16 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{linearLogRecur}
+    /* 线性对数阶 */
+    int linearLogRecur(float n) {
+        if (n <= 1)
+            return 1;
+        int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+        for (int i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -2359,7 +2450,16 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-    [class]{}-[func]{factorialRecur}
+    /* 阶乘阶（递归实现） */
+    int factorialRecur(int n) {
+        if (n == 0)
+            return 1;
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            count += factorialRecur(n - 1);
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -2606,9 +2706,34 @@ $$
 === "C"
 
     ```c title="worst_best_time_complexity.c"
-    [class]{}-[func]{randomNumbers}
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    int *randomNumbers(int n) {
+        // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
+        int *nums = (int *)malloc(n * sizeof(int));
+        // 生成数组 nums = { 1, 2, 3, ..., n }
+        for (int i = 0; i < n; i++) {
+            nums[i] = i + 1;
+        }
+        // 随机打乱数组元素
+        for (int i = n - 1; i > 0; i--) {
+            int j = rand() % (i + 1);
+            int temp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = temp;
+        }
+        return nums;
+    }
 
-    [class]{}-[func]{findOne}
+    /* 查找数组 nums 中数字 1 所在索引 */
+    int findOne(int *nums, int n) {
+        for (int i = 0; i < n; i++) {
+            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
+            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
+            if (nums[i] == 1)
+                return i;
+        }
+        return -1;
+    }
     ```
 
 === "C#"