Add the section of radix sort. (#441)

docs/chapter_sorting/bucket_sort.md

@@ -1,6 +1,8 @@
 # 桶排序
 
-「桶排序 Bucket Sort」是分治思想的典型体现，其通过设置一些桶，将数据平均分配到各个桶中，并在每个桶内部分别执行排序，最终根据桶之间天然的大小顺序将各个桶内元素合并，从而得到排序结果。
+前面介绍的几种排序算法都属于 **基于比较的排序算法**，即通过比较元素之间的大小来实现排序，此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将学习几种 **非比较排序算法** ，其时间复杂度可以达到线性级别。
+
+「桶排序 Bucket Sort」是分治思想的典型体现，其通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中，并在每个桶内部分别执行排序，最终按照桶的顺序将所有数据合并即可。
 
 ## 算法流程
 
@@ -72,9 +74,9 @@
     [class]{}-[func]{bucketSort}
     ```
 
-!!! note "桶排序是计数排序的一种推广"
+!!! question "桶排序的应用场景是什么？" 
 
-    从桶排序的角度，我们可以把计数排序中计数数组 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把各个元素分配到对应的桶中，再根据桶之间的有序性输出结果，从而实现排序。
+    桶排序一般用于排序超大体量的数据。例如输入数据包含 100 万个元素，由于空间有限，系统无法一次性将所有数据加载进内存，那么可以先将数据划分到 1000 个桶里，再依次排序每个桶，最终合并结果即可。
 
 ## 算法特性
 

docs/chapter_sorting/counting_sort.md

@@ -1,6 +1,6 @@
 # 计数排序
 
-前面介绍的几种排序算法都属于 **基于比较的排序算法**，即通过比较元素之间的大小来实现排序，此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将学习一种 **非比较排序算法** ，名为「计数排序 Counting Sort」，其时间复杂度可以达到 $O(n)$ 。
+顾名思义，「计数排序 Counting Sort」通过统计元素数量来实现排序，一般应用于整数数组。
 
 ## 简单实现
 
@@ -10,8 +10,6 @@
 2. **借助 `counter` 统计 `nums` 中各数字的出现次数**，其中 `counter[num]` 对应数字 `num` 的出现次数。统计方法很简单，只需遍历 `nums` （设当前数字为 `num`），每轮将 `counter[num]` 自增 $1$ 即可。
 3. **由于 `counter` 的各个索引是天然有序的，因此相当于所有数字已经被排序好了**。接下来，我们遍历 `counter` ，根据各数字的出现次数，将各数字按从小到大的顺序填入 `nums` 即可。
 
-观察发现，计数排序名副其实，是通过“统计元素数量”来实现排序的。
-
 ![计数排序流程](counting_sort.assets/counting_sort_overview.png)
 
 === "Java"
@@ -74,6 +72,10 @@
     [class]{}-[func]{countingSortNaive}
     ```
 
+!!! note "计数排序与桶排序的联系"
+
+    从桶排序的角度看，我们可以把计数排序中计数数组 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
+
 ## 完整实现
 
 细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
@@ -181,7 +183,7 @@ $$
 
 **时间复杂度 $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` 也可以得到正确的排序结果，但结果“非稳定”。
 
@@ -191,4 +193,4 @@ $$
 
 **计数排序只适用于非负整数**。若想要用在其他类型数据上，则要求该数据必须可以被转化为非负整数，并且不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。
 
-**计数排序只适用于数据范围不大的情况**。比如，上述示例中 $m$ 不能太大，否则占用空间太多；而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，有可能比 $O(n \log n)$ 的排序算法还要慢。
+**计数排序适用于数据量大但数据范围不大的情况**。比如，上述示例中 $m$ 不能太大，否则占用空间太多；而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，有可能比 $O(n \log n)$ 的排序算法还要慢。

docs/chapter_sorting/insertion_sort.md

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

docs/chapter_sorting/quick_sort.md

@@ -115,16 +115,6 @@
     [class]{QuickSort}-[func]{partition}
     ```
 
-!!! 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]` 为基准数，那么正好反过来，必须先“从左往右查找”。
-
 ## 算法流程
 
 1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组**；
@@ -366,3 +356,13 @@
     ```zig title="quick_sort.zig"
     [class]{QuickSortTailCall}-[func]{quickSort}
     ```
+
+!!! 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]` 为基准数，那么正好反过来，必须先“从左往右查找”。

docs/chapter_sorting/radix_sort.md

@@ -0,0 +1,137 @@
+# 基数排序
+
+上节介绍的计数排序适用于数据量 $n$ 大但数据范围 $m$ 不大的情况。假设需要排序 $n = 10^6$ 个学号数据，学号是 $8$ 位数字，那么数据范围 $m = 10^8$ 很大，使用计数排序则需要开辟巨大的内存空间，而基数排序则可以避免这种情况。
+
+「基数排序 Radix Sort」主体思路与计数排序一致，也通过统计出现次数实现排序，**并在此基础上利用位与位之间的递进关系，依次对每一位执行排序**，从而获得排序结果。
+
+## 算法流程
+
+以上述的学号数据为例，设数字最低位为第 $1$ 位、最高位为第 $8$ 位，基数排序的流程为：
+
+1. 初始化位数 $k = 1$ ；
+2. 对学号的第 $k$ 位执行「计数排序」，完成后，数据即按照第 $k$ 位从小到大排序；
+3. 将 $k$ 自增 $1$ ，并返回第 `2.` 步继续迭代，直至排序完所有位后结束；
+
+![基数排序算法流程](radix_sort.assets/radix_sort_overview.png)
+
+下面来剖析代码实现。对于一个 $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"
+    [class]{radix_sort}-[func]{digit}
+
+    [class]{radix_sort}-[func]{countingSortDigit}
+
+    [class]{radix_sort}-[func]{radixSort}
+    ```
+
+=== "C++"
+
+    ```cpp title="radix_sort.cpp"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+=== "Python"
+
+    ```python title="radix_sort.py"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{counting_sort_digit}
+
+    [class]{}-[func]{radix_sort}
+    ```
+
+=== "Go"
+
+    ```go title="radix_sort.go"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+=== "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"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+=== "Zig"
+
+    ```zig title="radix_sort.zig"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{countingSortDigit}
+
+    [class]{}-[func]{radixSort}
+    ```
+
+!!! question "为什么从最低位开始排序？"
+
+    对于先后两轮排序，第二轮排序可能会覆盖第一轮排序的结果，比如第一轮认为 $a < b$ ，而第二轮认为 $a > b$ ，则第二轮会取代第一轮的结果。由于数字高位比低位的优先级更高，所以要先排序低位再排序高位。
+
+## 算法特性
+
+**时间复杂度 $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)$ 。