build

chapter_sorting/bucket_sort.md

@@ -2,11 +2,13 @@
 comments: true
 ---
 
-# 11.7.   桶排序
+# 11.6.   桶排序
 
-「桶排序 Bucket Sort」是分治思想的典型体现，其通过设置一些桶，将数据平均分配到各个桶中，并在每个桶内部分别执行排序，最终根据桶之间天然的大小顺序将各个桶内元素合并，从而得到排序结果。
+前面介绍的几种排序算法都属于 **基于比较的排序算法**，即通过比较元素之间的大小来实现排序，此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将学习几种 **非比较排序算法** ，其时间复杂度可以达到线性级别。
 
-## 11.7.1.   算法流程
+「桶排序 Bucket Sort」是分治思想的典型体现，其通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中，并在每个桶内部分别执行排序，最终按照桶的顺序将所有数据合并即可。
+
+## 11.6.1.   算法流程
 
 输入一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数，桶排序流程为：
 
@@ -105,11 +107,11 @@ comments: true
     [class]{}-[func]{bucketSort}
     ```
 
-!!! note "桶排序是计数排序的一种推广"
+!!! question "桶排序的应用场景是什么？" 
 
-    从桶排序的角度，我们可以把计数排序中计数数组 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把各个元素分配到对应的桶中，再根据桶之间的有序性输出结果，从而实现排序。
+    桶排序一般用于排序超大体量的数据。例如输入数据包含 100 万个元素，由于空间有限，系统无法一次性将所有数据加载进内存，那么可以先将数据划分到 1000 个桶里，再依次排序每个桶，最终合并结果即可。
 
-## 11.7.2.   算法特性
+## 11.6.2.   算法特性
 
 **时间复杂度 $O(n + k)$** ：假设元素平均分布在各个桶内，则每个桶内元素数量为 $\frac{n}{k}$ 。假设排序单个桶使用 $O(\frac{n}{k} \log\frac{n}{k})$ 时间，则排序所有桶使用 $O(n \log\frac{n}{k})$ 时间，**当桶数量 $k$ 比较大时，时间复杂度则趋向于 $O(n)$** 。最后合并结果需要遍历 $n$ 个桶，使用 $O(k)$ 时间。
 
@@ -119,7 +121,7 @@ comments: true
 
 桶排序是否稳定取决于排序桶内元素的算法是否稳定。
 
-## 11.7.3.   如何实现平均分配
+## 11.6.3.   如何实现平均分配
 
 桶排序的时间复杂度理论上可以达到 $O(n)$ ，**难点是需要将元素均匀分配到各个桶中**，因为现实中的数据往往都不是均匀分布的。举个例子，假设我们想要把淘宝的所有商品根据价格范围平均分配到 10 个桶中，然而商品价格不是均匀分布的，100 元以下非常多、1000 元以上非常少；如果我们将价格区间平均划为 10 份，那么各个桶内的商品数量差距会非常大。
 

chapter_sorting/counting_sort.md

@@ -2,11 +2,11 @@
 comments: true
 ---
 
-# 11.6.   计数排序
+# 11.7.   计数排序
 
-前面介绍的几种排序算法都属于 **基于比较的排序算法**，即通过比较元素之间的大小来实现排序，此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将学习一种 **非比较排序算法** ，名为「计数排序 Counting Sort」，其时间复杂度可以达到 $O(n)$ 。
+顾名思义，「计数排序 Counting Sort」通过统计元素数量来实现排序，一般应用于整数数组。
 
-## 11.6.1.   简单实现
+## 11.7.1.   简单实现
 
 先看一个简单例子。给定一个长度为 $n$ 的数组 `nums` ，元素皆为 **非负整数**。计数排序的整体流程为：
 
@@ -14,8 +14,6 @@ comments: true
 2. **借助 `counter` 统计 `nums` 中各数字的出现次数**，其中 `counter[num]` 对应数字 `num` 的出现次数。统计方法很简单，只需遍历 `nums` （设当前数字为 `num`），每轮将 `counter[num]` 自增 $1$ 即可。
 3. **由于 `counter` 的各个索引是天然有序的，因此相当于所有数字已经被排序好了**。接下来，我们遍历 `counter` ，根据各数字的出现次数，将各数字按从小到大的顺序填入 `nums` 即可。
 
-观察发现，计数排序名副其实，是通过“统计元素数量”来实现排序的。
-
 ![计数排序流程](counting_sort.assets/counting_sort_overview.png)
 
 <p align="center"> Fig. 计数排序流程 </p>
@@ -181,7 +179,11 @@ comments: true
     [class]{}-[func]{countingSortNaive}
     ```
 
-## 11.6.2. &nbsp; 完整实现
+!!! note "计数排序与桶排序的联系"
+
+    从桶排序的角度看，我们可以把计数排序中计数数组 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
+
+## 11.7.2. &nbsp; 完整实现
 
 细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
 
@@ -432,18 +434,18 @@ $$
     [class]{}-[func]{countingSort}
     ```
 
-## 11.6.3. &nbsp; 算法特性
+## 11.7.3. &nbsp; 算法特性
 
 **时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，此时使用线性 $O(n)$ 时间。
 
-**空间复杂度 $O(n + m)$** ：借助了长度分别为 $n$ , $m$ 的数组 `res` 和 `counter` ，是“非原地排序”；
+**空间复杂度 $O(n + m)$** ：借助了长度分别为 $n$ , $m$ 的数组 `res` 和 `counter` ，是“非原地排序”。
 
 **稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现“稳定排序”；其实正序遍历 `nums` 也可以得到正确的排序结果，但结果“非稳定”。
 
-## 11.6.4. &nbsp; 局限性
+## 11.7.4. &nbsp; 局限性
 
 看到这里，你也许会觉得计数排序太妙了，咔咔一通操作，时间复杂度就下来了。然而，使用技术排序的前置条件比较苛刻。
 
 **计数排序只适用于非负整数**。若想要用在其他类型数据上，则要求该数据必须可以被转化为非负整数，并且不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。
 
-**计数排序只适用于数据范围不大的情况**。比如，上述示例中 $m$ 不能太大，否则占用空间太多；而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，有可能比 $O(n \log n)$ 的排序算法还要慢。
+**计数排序适用于数据量大但数据范围不大的情况**。比如，上述示例中 $m$ 不能太大，否则占用空间太多；而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，有可能比 $O(n \log n)$ 的排序算法还要慢。

chapter_sorting/insertion_sort.md

@@ -207,16 +207,16 @@ comments: true
 
 在插入操作中，我们会将元素插入到相等元素的右边，不会改变它们的次序，因此是“稳定排序”。
 
-## 11.3.3.   插入排序 vs 冒泡排序
+## 11.3.3.   插入排序优势
 
 回顾「冒泡排序」和「插入排序」的复杂度分析，两者的循环轮数都是 $\frac{(n - 1) n}{2}$ 。但不同的是：
 
 - 冒泡操作基于 **元素交换** 实现，需要借助一个临时变量实现，共 3 个单元操作；
 - 插入操作基于 **元素赋值** 实现，只需 1 个单元操作；
 
-因此，可以粗略估计出冒泡排序的计算开销约为插入排序的 3 倍，因此更受欢迎。实际上，许多编程语言（例如 Java）的内置排序函数都使用到了插入排序，大致思路为：
+粗略估计，冒泡排序的计算开销约为插入排序的 3 倍，因此插入排序更受欢迎，许多编程语言（例如 Java）的内置排序函数都使用到了插入排序，大致思路为：
 
 - 对于 **长数组**，采用基于分治的排序算法，例如「快速排序」，时间复杂度为 $O(n \log n)$ ；
 - 对于 **短数组**，直接使用「插入排序」，时间复杂度为 $O(n^2)$ ；
 
-**在数据量较小时插入排序更快**，这是因为复杂度中的常数项（即每轮中的单元操作数量）占主导作用。这个现象与「线性查找」和「二分查找」的情况类似。
+虽然插入排序比快速排序的时间复杂度更高，**但实际上在数据量较小时插入排序更快**，这是因为复杂度中的常数项（即每轮中的单元操作数量）占主导作用。这个现象与「线性查找」和「二分查找」的情况类似。

chapter_sorting/quick_sort.md

@@ -286,16 +286,6 @@ comments: true
     }
     ```
 
-!!! question "“从右往左查找”与“从左往右查找”顺序可以交换吗？"
-
-    不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。
-
-    哨兵划分 `partition()` 的最后一步是交换 `nums[left]` 和 `nums[i]` ，完成交换后，基准数左边的元素都 `<=` 基准数，**这就要求最后一步交换前 `nums[left] >= nums[i]` 必须成立**。假设我们先“从左往右查找”，那么如果找不到比基准数更小的元素，**则会在 `i == j` 时跳出循环，此时可能 `nums[j] == nums[i] > nums[left]`** ；也就是说，此时最后一步交换操作会把一个比基准数更大的元素交换至数组最左端，导致哨兵划分失败。
-
-    举个例子，给定数组 `[0, 0, 0, 0, 1]` ，如果先“从左向右查找”，哨兵划分后数组为 `[1, 0, 0, 0, 0]` ，这个结果是不对的。
-
-    再深想一步，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。
-
 ## 11.4.1. &nbsp; 算法流程
 
 1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组**；
@@ -1006,3 +996,13 @@ comments: true
         }
     }
     ```
+
+!!! question "哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？"
+
+    不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。
+
+    哨兵划分 `partition()` 的最后一步是交换 `nums[left]` 和 `nums[i]` ，完成交换后，基准数左边的元素都 `<=` 基准数，**这就要求最后一步交换前 `nums[left] >= nums[i]` 必须成立**。假设我们先“从左往右查找”，那么如果找不到比基准数更小的元素，**则会在 `i == j` 时跳出循环，此时可能 `nums[j] == nums[i] > nums[left]`** ；也就是说，此时最后一步交换操作会把一个比基准数更大的元素交换至数组最左端，导致哨兵划分失败。
+
+    举个例子，给定数组 `[0, 0, 0, 0, 1]` ，如果先“从左向右查找”，哨兵划分后数组为 `[1, 0, 0, 0, 0]` ，这个结果是不对的。
+
+    再深想一步，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。

chapter_sorting/radix_sort.md

@@ -0,0 +1,409 @@
+---
+comments: true
+---
+
+# 11.8.   基数排序
+
+上节介绍的计数排序适用于数据量 $n$ 大但数据范围 $m$ 不大的情况。假设需要排序 $n = 10^6$ 个学号数据，学号是 $8$ 位数字，那么数据范围 $m = 10^8$ 很大，使用计数排序则需要开辟巨大的内存空间，而基数排序则可以避免这种情况。
+
+「基数排序 Radix Sort」主体思路与计数排序一致，也通过统计出现次数实现排序，**并在此基础上利用位与位之间的递进关系，依次对每一位执行排序**，从而获得排序结果。
+
+## 11.8.1.   算法流程
+
+以上述的学号数据为例，设数字最低位为第 $1$ 位、最高位为第 $8$ 位，基数排序的流程为：
+
+1. 初始化位数 $k = 1$ ；
+2. 对学号的第 $k$ 位执行「计数排序」，完成后，数据即按照第 $k$ 位从小到大排序；
+3. 将 $k$ 自增 $1$ ，并返回第 `2.` 步继续迭代，直至排序完所有位后结束；
+
+![基数排序算法流程](radix_sort.assets/radix_sort_overview.png)
+
+<p align="center"> Fig. 基数排序算法流程 </p>
+
+下面来剖析代码实现。对于一个 $d$ 进制的数字 $x$ ，其第 $k$ 位 $x_k$ 的计算公式为
+
+$$
+x_k = \lfloor\frac{x}{d^{k-1}}\rfloor \mod d
+$$
+
+其中 $\lfloor a \rfloor$ 代表对浮点数 $a$ 执行向下取整，$\mod d$ 代表对 $d$ 取余。学号数据的 $d = 10$ , $k \in [1, 8]$ 。
+
+此外，我们需要小幅改动计数排序代码，使之可以根据数字第 $k$ 位执行排序。
+
+=== "Java"
+
+    ```java title="radix_sort.java"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(int[] nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int[] counter = new int[10];
+        int n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
+
+    /* 基数排序 */
+    void radixSort(int[] nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = Integer.MIN_VALUE;
+        for (int num : nums)
+            if (num > m) m = num;
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="radix_sort.cpp"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(vector<int>& nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        vector<int> counter(10, 0);
+        int n = nums.size();
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        vector<int> res(n, 0);
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
+
+    /* 基数排序 */
+    void radixSort(vector<int>& nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = *max_element(nums.begin(), nums.end());
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+    }
+    ```
+
+=== "Python"
+
+    ```python title="radix_sort.py"
+    def digit(num: int, exp: int) -> int:
+        """ 获取元素 num 的第 k 位，其中 exp = 10^(k-1) """
+        # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num // exp) % 10
+
+    def counting_sort_digit(nums: list[int], exp: int) -> None:
+        """ 计数排序（根据 nums 第 k 位排序） """
+        # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        counter = [0] * 10
+        n = len(nums)
+        # 统计 0~9 各数字的出现次数
+        for i in range(n):
+            d = digit(nums[i], exp)  # 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1          # 统计数字 d 的出现次数
+        # 求前缀和，将“出现个数”转换为“数组索引”
+        for i in range(1, 10):
+            counter[i] += counter[i - 1]
+        # 倒序遍历，根据桶内统计结果，将各元素填入 res
+        res = [0] * n
+        for i in range(n - 1, -1, -1):
+            d = digit(nums[i], exp)
+            j = counter[d] - 1  # 获取 d 在数组中的索引 j
+            res[j] = nums[i]    # 将当前元素填入索引 j
+            counter[d] -= 1     # 将 d 的数量减 1
+        # 使用结果覆盖原数组 nums
+        for i in range(n):
+            nums[i] = res[i]
+
+    def radix_sort(nums: list[int]) -> None:
+        """ 基数排序 """
+        # 获取数组的最大元素，用于判断最大位数
+        m = max(nums)
+        # 按照从低位到高位的顺序遍历
+        exp = 1
+        while exp <= m:
+            # 对数组元素的第 k 位执行计数排序
+            # k = 1 -> exp = 1
+            # k = 2 -> exp = 10
+            # 即 exp = 10^(k-1)
+            counting_sort_digit(nums, exp)
+            exp *= 10
+    ```
+
+=== "Go"
+
+    ```go title="radix_sort.go"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num, exp int) int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    func countingSortDigit(nums []int, exp int) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        counter := make([]int, 10)
+        n := len(nums)
+        // 统计 0~9 各数字的出现次数
+        for i := 0; i < n; i++ {
+            d := digit(nums[i], exp) // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++             // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i := 1; i < 10; i++ {
+            counter[i] += counter[i-1]
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        res := make([]int, n)
+        for i := n - 1; i >= 0; i-- {
+            d := digit(nums[i], exp)
+            j := counter[d] - 1 // 获取 d 在数组中的索引 j
+            res[j] = nums[i]    // 将当前元素填入索引 j
+            counter[d]--        // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i := 0; i < n; i++ {
+            nums[i] = res[i]
+        }
+    }
+
+    /* 基数排序 */
+    func radixSort(nums []int) {
+        // 获取数组的最大元素，用于判断最大位数
+        max := math.MinInt
+        for _, num := range nums {
+            if num > max {
+                max = num
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for exp := 1; max >= exp; exp *= 10 {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp)
+        }
+    }
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="radix_sort.js"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="radix_sort.ts"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+=== "C"
+
+    ```c title="radix_sort.c"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+=== "C#"
+
+    ```csharp title="radix_sort.cs"
+    [class]{radix_sort}-[func]{digit}
+
+    [class]{radix_sort}-[func]{countingSortDigit}
+
+    [class]{radix_sort}-[func]{radixSort}
+    ```
+
+=== "Swift"
+
+    ```swift title="radix_sort.swift"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num: Int, exp: Int) -> Int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        (num / exp) % 10
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    func countingSortDigit(nums: inout [Int], exp: Int) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        var counter = Array(repeating: 0, count: 10)
+        let n = nums.count
+        // 统计 0~9 各数字的出现次数
+        for i in nums.indices {
+            let d = digit(num: nums[i], exp: exp) // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1 // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i in 1 ..< 10 {
+            counter[i] += counter[i - 1]
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        var res = Array(repeating: 0, count: n)
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            let d = digit(num: nums[i], exp: exp)
+            let j = counter[d] - 1 // 获取 d 在数组中的索引 j
+            res[j] = nums[i] // 将当前元素填入索引 j
+            counter[d] -= 1 // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i in nums.indices {
+            nums[i] = res[i]
+        }
+    }
+
+    /* 基数排序 */
+    func radixSort(nums: inout [Int]) {
+        // 获取数组的最大元素，用于判断最大位数
+        var m = Int.min
+        for num in nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for exp in sequence(first: 1, next: { m >= ($0 * 10) ? $0 * 10 : nil }) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums: &nums, exp: exp)
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="radix_sort.zig"
+    // 获取元素 num 的第 k 位，其中 exp = 10^(k-1)
+    fn digit(num: i32, exp: i32) i32 {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return @mod(@divFloor(num, exp), 10);
+    }
+
+    // 计数排序（根据 nums 第 k 位排序）
+    fn countingSortDigit(nums: []i32, exp: i32) !void {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+        // defer mem_arena.deinit();
+        const mem_allocator = mem_arena.allocator();
+        var counter = try mem_allocator.alloc(usize, 10);
+        std.mem.set(usize, counter, 0);
+        var n = nums.len;
+        // 统计 0~9 各数字的出现次数
+        for (nums) |num| {
+            var d = @bitCast(u32, digit(num, exp)); // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        var i: usize = 1;
+        while (i < 10) : (i += 1) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        var res = try mem_allocator.alloc(i32, n);
+        i = n - 1;
+        while (i >= 0) : (i -= 1) {
+            var d = @bitCast(u32, digit(nums[i], exp));
+            var j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d] -= 1;        // 将 d 的数量减 1
+            if (i == 0) break;
+        }
+        // 使用结果覆盖原数组 nums
+        i = 0;
+        while (i < n) : (i += 1) {
+            nums[i] = res[i];
+        }
+    }
+
+    // 基数排序
+    fn radixSort(nums: []i32) !void {
+        // 获取数组的最大元素，用于判断最大位数
+        var m: i32 = std.math.minInt(i32);
+        for (nums) |num| {
+            if (num > m) m = num;
+        }
+        // 按照从低位到高位的顺序遍历
+        var exp: i32 = 1;
+        while (exp <= m) : (exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            try countingSortDigit(nums, exp);    
+        }
+    } 
+    ```
+
+!!! question "为什么从最低位开始排序？"
+
+    对于先后两轮排序，第二轮排序可能会覆盖第一轮排序的结果，比如第一轮认为 $a < b$ ，而第二轮认为 $a > b$ ，则第二轮会取代第一轮的结果。由于数字高位比低位的优先级更高，所以要先排序低位再排序高位。
+
+## 11.8.2. &nbsp; 算法特性
+
+**时间复杂度 $O(n k)$** ：设数据量为 $n$ 、数据为 $d$ 进制、最大为 $k$ 位，则对某一位执行计数排序使用 $O(n + d)$ 时间，排序 $k$ 位使用 $O((n + d)k)$ 时间；一般情况下 $d$ 和 $k$ 都比较小，此时时间复杂度近似为 $O(n)$ 。
+
+**空间复杂度 $O(n + d)$** ：与计数排序一样，借助了长度分别为 $n$ , $d$ 的数组 `res` 和 `counter` ，因此是“非原地排序”。
+
+与计数排序一致，基数排序也是稳定排序。相比于计数排序，基数排序可适用于数值范围较大的情况，**但前提是数据必须可以被表示为固定位数的格式，且位数不能太大**。比如浮点数就不适合使用基数排序，因为其位数 $k$ 太大，可能时间复杂度 $O(nk) \gg O(n^2)$ 。

chapter_sorting/summary.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.8.   小结
+# 11.9.   小结
 
 - 冒泡排序通过交换相邻元素来实现排序。通过增加标志位实现提前返回，我们可将冒泡排序的最佳时间复杂度优化至 $O(N)$ 。
 - 插入排序每轮将待排序区间内元素插入至已排序区间的正确位置，从而实现排序。插入排序的时间复杂度虽为 $O(N^2)$ ，但因为总体操作少而很受欢迎，一般用于小数据量的排序工作。