build

chapter_computational_complexity/time_complexity.md

@@ -3008,6 +3008,7 @@ $$
         // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
         if (nums[i] == 1) return i;
       }
+
       return -1;
     }
     ```

chapter_searching/binary_search_edge.md

@@ -163,7 +163,22 @@ comments: true
 === "C"
 
     ```c title="binary_search_edge.c"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个元素 */
+    int binarySearchLeftEdge(int *nums, int size, int target) {
+        int i = 0, j = size - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)
+                i = m + 1; // target 在区间 [m+1, j] 中
+            else if (nums[m] > target)
+                j = m - 1; // target 在区间 [i, m-1] 中
+            else
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+        }
+        if (i == size || nums[i] != target)
+            return -1; // 未找到目标元素，返回 -1
+        return i;
+    }
     ```
 
 === "C#"
@@ -221,7 +236,21 @@ comments: true
 === "Dart"
 
     ```dart title="binary_search_edge.dart"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个元素 */
+    int binarySearchLeftEdge(List<int> nums, int target) {
+      int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中间索引 m
+        if (nums[m] < target)
+          i = m + 1; // target 在区间 [m+1, j] 中
+        else if (nums[m] > target)
+          j = m - 1; // target 在区间 [i, m-1] 中
+        else
+          j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+      }
+      if (i == nums.length || nums[i] != target) return -1; // 未找到目标元素，返回 -1
+      return i;
+    }
     ```
 
 ## 10.2.3. &nbsp; 查找右边界
@@ -335,7 +364,22 @@ comments: true
 === "C"
 
     ```c title="binary_search_edge.c"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个元素 */
+    int binarySearchRightEdge(int *nums, int size, int target) {
+        int i = 0, j = size - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)
+                i = m + 1; // target 在区间 [m+1, j] 中
+            else if (nums[m] > target)
+                j = m - 1; // target 在区间 [i, m-1] 中
+            else
+                i = m + 1; // 首个大于 target 的元素在区间 [m+1, j] 中
+        }
+        if (j < 0 || nums[j] != target)
+            return -1; // 未找到目标元素，返回 -1
+        return j;
+    }
     ```
 
 === "C#"
@@ -393,7 +437,21 @@ comments: true
 === "Dart"
 
     ```dart title="binary_search_edge.dart"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个元素 */
+    int binarySearchRightEdge(List<int> nums, int target) {
+      int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中间索引 m
+        if (nums[m] < target)
+          i = m + 1; // target 在区间 [m+1, j] 中
+        else if (nums[m] > target)
+          j = m - 1; // target 在区间 [i, m-1] 中
+        else
+          i = m + 1; // 首个大于 target 的元素在区间 [m+1, j] 中
+      }
+      if (j < 0 || nums[j] != target) return -1; // 未找到目标元素，返回 -1
+      return j;
+    }
     ```
 
 观察下图，搜索最右边元素时指针 $j$ 的作用与搜索最左边元素时指针 $i$ 的作用一致，反之亦然。也就是说，**搜索最左边元素和最右边元素的实现是镜像对称的**。

chapter_sorting/bucket_sort.md

@@ -212,7 +212,53 @@ comments: true
 === "C"
 
     ```c title="bucket_sort.c"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    void bucketSort(float nums[], int size) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = size / 2;
+        float **buckets = calloc(k, sizeof(float *));
+        for (int i = 0; i < k; i++) {
+            // 每个桶最多可以分配 k 个元素
+            buckets[i] = calloc(ARRAY_SIZE, sizeof(float));
+        }
+
+        // 1. 将数组元素分配到各个桶中
+        for (int i = 0; i < size; i++) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int bucket_idx = nums[i] * k;
+            int j = 0;
+            // 如果桶中有数据且数据小于当前值 nums[i], 要将其放到当前桶的后面，相当于 cpp 中的 push_back
+            while (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {
+                j++;
+            }
+            float temp = nums[i];
+            while (j < ARRAY_SIZE && buckets[bucket_idx][j] > 0) {
+                swap(&temp, &buckets[bucket_idx][j]);
+                j++;
+            }
+            buckets[bucket_idx][j] = temp;
+        }
+
+        // 2. 对各个桶执行排序
+        for (int i = 0; i < k; i++) {
+            qsort(buckets[i], ARRAY_SIZE, sizeof(float), compare_float);
+        }
+
+        // 3. 遍历桶合并结果
+        for (int i = 0, j = 0; j < k; j++) {
+            for (int l = 0; l < ARRAY_SIZE; l++) {
+                if (buckets[j][l] > 0) {
+                    nums[i++] = buckets[j][l];
+                }
+            }
+        }
+
+        // 释放上述分配的内存
+        for (int i = 0; i < k; i++) {
+            free(buckets[i]);
+        }
+        free(buckets);
+    }
     ```
 
 === "C#"

chapter_sorting/heap_sort.md

@@ -246,9 +246,46 @@ comments: true
 === "C"
 
     ```c title="heap_sort.c"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(int nums[], int n, int i) {
+        while (1) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            if (ma == i) {
+                break;
+            }
+            // 交换两节点
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(int nums[], int n) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = n / 2 - 1; i >= 0; --i) {
+            siftDown(nums, n, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = n - 1; i > 0; --i) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "C#"
@@ -346,9 +383,42 @@ comments: true
 === "Dart"
 
     ```dart title="heap_sort.dart"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(List<int> nums, int n, int i) {
+      while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = 2 * i + 1;
+        int r = 2 * i + 2;
+        int ma = i;
+        if (l < n && nums[l] > nums[ma]) ma = l;
+        if (r < n && nums[r] > nums[ma]) ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        if (ma == i) break;
+        // 交换两节点
+        int temp = nums[i];
+        nums[i] = nums[ma];
+        nums[ma] = temp;
+        // 循环向下堆化
+        i = ma;
+      }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(List<int> nums) {
+      // 建堆操作：堆化除叶节点以外的其他所有节点
+      for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {
+        siftDown(nums, nums.length, i);
+      }
+      // 从堆中提取最大元素，循环 n-1 轮
+      for (int i = nums.length - 1; i > 0; i--) {
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        int tmp = nums[0];
+        nums[0] = nums[i];
+        nums[i] = tmp;
+        // 以根节点为起点，从顶至底进行堆化
+        siftDown(nums, i, 0);
+      }
+    }
     ```
 
 ## 11.7.2. &nbsp; 算法特性

chapter_sorting/selection_sort.md

@@ -146,7 +146,22 @@ comments: true
 === "C"
 
     ```c title="selection_sort.c"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(int nums[], int n) {
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j;  // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
     ```
 
 === "C#"
@@ -198,7 +213,22 @@ comments: true
 === "Dart"
 
     ```dart title="selection_sort.dart"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(List<int> nums) {
+      int n = nums.length;
+      // 外循环：未排序区间为 [i, n-1]
+      for (int i = 0; i < n - 1; i++) {
+        // 内循环：找到未排序区间内的最小元素
+        int k = i;
+        for (int j = i + 1; j < n; j++) {
+          if (nums[j] < nums[k]) k = j; // 记录最小元素的索引
+        }
+        // 将该最小元素与未排序区间的首个元素交换
+        int temp = nums[i];
+        nums[i] = nums[k];
+        nums[k] = temp;
+      }
+    }
     ```
 
 ## 11.2.1. &nbsp; 算法特性