build

chapter_sorting/counting_sort.md

@@ -265,6 +265,33 @@ comments: true
     [class]{}-[func]{countingSortNaive}
     ```
 
+=== "Dart"
+
+    ```dart title="counting_sort.dart"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(List<int> nums) {
+      // 1. 统计数组最大元素 m
+      int m = 0;
+      for (int num in nums) {
+        m = max(m, num);
+      }
+     // 2. 统计各数字的出现次数
+      // counter[num] 代表 num 的出现次数
+      List<int> counter = List.filled(m + 1, 0);
+      for (int num in nums) {
+        counter[num]++;
+      }
+      // 3. 遍历 counter ，将各元素填入原数组 nums
+      int i = 0;
+      for (int num = 0; num < m + 1; num++) {
+        for (int j = 0; j < counter[num]; j++, i++) {
+          nums[i] = num;
+        }
+      }
+    }
+    ```
+
 !!! note "计数排序与桶排序的联系"
 
     从桶排序的角度看，我们可以将计数排序中的计数数组 `counter` 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
@@ -647,6 +674,42 @@ $$
     [class]{}-[func]{countingSort}
     ```
 
+=== "Dart"
+
+    ```dart title="counting_sort.dart"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(List<int> nums) {
+      // 1. 统计数组最大元素 m
+      int m = 0;
+      for (int num in nums) {
+        m = max(m, num);
+      }
+      // 2. 统计各数字的出现次数
+      // counter[num] 代表 num 的出现次数
+      List<int> counter = List.filled(m + 1, 0);
+      for (int num in nums) {
+        counter[num]++;
+      }
+      // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+      // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+      for (int i = 0; i < m; i++) {
+        counter[i + 1] += counter[i];
+      }
+      // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+      // 初始化数组 res 用于记录结果
+      int n = nums.length;
+      List<int> res = List.filled(n, 0);
+      for (int i = n - 1; i >= 0; i--) {
+        int num = nums[i];
+        res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+        counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
+      }
+      // 使用结果数组 res 覆盖原数组 nums
+      nums.setAll(0, res);
+    }
+    ```
+
 ## 11.9.3. &nbsp; 算法特性
 
 - **时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。