build

chapter_sorting/bucket_sort.md

@@ -1,20 +1,136 @@
-# 桶排序
+---
+comments: true
+---
 
-「桶排序 Bucket Sort」考虑设置 $k$ 个桶，并将 $n$ 个元素根据大小分配到 $k$ 个桶中，**并在每个桶内部分别执行排序**，由于桶之间的大小关系的确定的，因此最后按照桶之间的顺序将元素依次展开即可。
+# 11.7.   桶排序
 
-假设元素平均分布在各个桶内，则每个桶内元素数量为 $\frac{n}{k}$ ；如果使用「快速排序」来实现桶内排序，则排序单个桶使用 $O(\frac{n}{k} \log\frac{n}{k})$ 时间，排序所有桶使用 $O(n \log\frac{n}{k})$ 时间。**当桶数量 $k$ 比较大时，时间复杂度则趋向于 $O(n)$** 。
+「桶排序 Bucket Sort」是分治思想的典型体现，其通过设置一些桶，将数据平均分配到各个桶中，并在每个桶内部分别执行排序，最终根据桶之间天然的大小顺序将各个桶内元素合并，从而得到排序结果。
 
-!!! note 计数排序与桶排序的关系
+## 11.7.1.   算法流程
 
-    **计数排序可以看作是桶排序的一种特例**。我们可以把计数排序中 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把 $n$ 个元素分配到对应的桶中，再根据桶之间的有序性输出结果，从而实现排序。
+输入一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数，桶排序流程为：
 
-（图）
+1. 初始化 $k$ 个桶，将 $n$ 个元素分配至 $k$ 个桶中；
+2. 对每个桶分别执行排序（本文采用编程语言的内置排序函数）；
+3. 按照桶的从小到大的顺序，合并结果；
 
-理论上桶排序的时间复杂度是 $O(n)$ ，**但前提是需要将元素均匀分配到各个桶中**，而这并不容易做到。假设想要把淘宝的 $100$ 万件商品根据价格范围平均分配到 $100$ 个桶中，而商品价格不是均匀分布的，例如 $100$ 元以下的商品非常多、$1000$ 元以上的商品非常少等。如果我们将价格区间平均划分为 $100$ 份，那么各个桶内的商品数量差距会非常大。为了实现平均分配，我们一般这样做：
+![桶排序算法流程](bucket_sort.assets/bucket_sort_overview.png)
 
-- 先粗略设置分界线，将元素分配完后，**把元素较多的桶继续划分为多个桶**，直至所有桶内元素数量合理为止；该做法本质上是一个递归树；
+<p align="center"> Fig. 桶排序算法流程 </p>
-- 如果我们提前知道商品价格的概率分布，**则可以根据已知分布来设置每个桶的价格分界线**；值得说明的是，数据分布不一定需要特意统计，也可以根据数据特点采用某种常见概率模型来近似，例如自然界的正态分布等；
 
-（图）
+=== "Java"
 
-另外，排序桶内元素需要选择一种合适的排序算法，比如快速排序。
+    ```java title="bucket_sort.java"
+    /* 桶排序 */
+    void bucketSort(float[] nums) {
+        // 初始化 k = n/3 个桶，预期向每个桶分配 3 个元素
+        int k = nums.length / 2;
+        List<List<Float>> buckets = new ArrayList<>();
+        for (int i = 0; i < k; i++) {
+            buckets.add(new ArrayList<>());
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (float num : nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = (int) num * k;
+            // 将 num 添加进桶 i
+            buckets.get(i).add(num);
+        }
+        // 2. 对各个桶执行排序
+        for (List<Float> bucket : buckets) {
+            // 使用内置排序函数，也可以替换成其它排序算法
+            Collections.sort(bucket);
+        }
+        // 3. 遍历桶合并结果
+        int i = 0;
+        for (List<Float> bucket : buckets) {
+            for (float num : bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="bucket_sort.cpp"
+    [class]{}-[func]{bucketSort}
+    ```
+
+=== "Python"
+
+    ```python title="bucket_sort.py"
+    [class]{}-[func]{bucket_sort}
+    ```
+
+=== "Go"
+
+    ```go title="bucket_sort.go"
+    [class]{}-[func]{bucketSort}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="bucket_sort.js"
+    [class]{}-[func]{bucketSort}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="bucket_sort.ts"
+    [class]{}-[func]{bucketSort}
+    ```
+
+=== "C"
+
+    ```c title="bucket_sort.c"
+    [class]{}-[func]{bucketSort}
+    ```
+
+=== "C#"
+
+    ```csharp title="bucket_sort.cs"
+    [class]{bucket_sort}-[func]{bucketSort}
+    ```
+
+=== "Swift"
+
+    ```swift title="bucket_sort.swift"
+    [class]{}-[func]{bucketSort}
+    ```
+
+=== "Zig"
+
+    ```zig title="bucket_sort.zig"
+    [class]{}-[func]{bucketSort}
+    ```
+
+!!! note "桶排序是计数排序的一种推广"
+
+    从桶排序的角度，我们可以把计数排序中计数数组 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把各个元素分配到对应的桶中，再根据桶之间的有序性输出结果，从而实现排序。
+
+## 11.7.2. &nbsp; 算法特性
+
+**时间复杂度 $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)$ 时间。
+
+最差情况下，所有数据被分配到一个桶中，且排序算法退化至 $O(n^2)$ ，此时使用 $O(n^2)$ 时间，因此是“自适应排序”。
+
+**空间复杂度 $O(n + k)$** ：需要借助 $k$ 个桶和共 $n$ 个元素的额外空间，是“非原地排序”。
+
+桶排序是否稳定取决于排序桶内元素的算法是否稳定。
+
+## 11.7.3. &nbsp; 如何实现平均分配
+
+桶排序的时间复杂度理论上可以达到 $O(n)$ ，**难点是需要将元素均匀分配到各个桶中**，因为现实中的数据往往都不是均匀分布的。举个例子，假设我们想要把淘宝的所有商品根据价格范围平均分配到 10 个桶中，然而商品价格不是均匀分布的，100 元以下非常多、1000 元以上非常少；如果我们将价格区间平均划为 10 份，那么各个桶内的商品数量差距会非常大。
+
+为了实现平均分配，我们可以先大致设置一个分界线，将数据粗略分到 3 个桶，分配完后，**再把商品较多的桶继续划分为 3 个桶，直至所有桶内元素数量大致平均为止**。此方法本质上是生成一个递归树，让叶结点的值尽量平均。当然，不一定非要划分为 3 个桶，可以根据数据特点灵活选取。
+
+![递归划分桶](bucket_sort.assets/scatter_in_buckets_recursively.png)
+
+<p align="center"> Fig. 递归划分桶 </p>
+
+如果我们提前知道商品价格的概率分布，**那么也可以根据数据概率分布来设置每个桶的价格分界线**。注意，数据分布不一定需要特意去统计，也可以根据数据特点采用某种概率模型来近似。如下图所示，我们假设商品价格服从正态分布，就可以合理设置价格区间，将商品平均分配到各个桶中。
+
+![根据概率分布划分桶](bucket_sort.assets/scatter_in_buckets_distribution.png)
+
+<p align="center"> Fig. 根据概率分布划分桶 </p>

chapter_sorting/quick_sort.md

@@ -54,7 +54,7 @@ comments: true
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-
+    
     /* 哨兵划分 */
     int partition(int[] nums, int left, int right) {
         // 以 nums[left] 作为基准数
@@ -80,7 +80,7 @@ comments: true
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-
+    
     /* 哨兵划分 */
     int partition(vector<int>& nums, int left, int right) {
         // 以 nums[left] 作为基准数
@@ -148,7 +148,7 @@ comments: true
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-
+    
     /* 哨兵划分 */
     partition(nums, left, right) {
         // 以 nums[left] 作为基准数
@@ -177,7 +177,7 @@ comments: true
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-
+    
     /* 哨兵划分 */
     partition(nums: number[], left: number, right: number): number {
         // 以 nums[left] 作为基准数
@@ -213,7 +213,7 @@ comments: true
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-
+    
     /* 哨兵划分 */
     int partition(int[] nums, int left, int right)
     {
@@ -241,7 +241,7 @@ comments: true
         nums[i] = nums[j]
         nums[j] = tmp
     }
-
+    
     /* 哨兵划分 */
     func partition(nums: inout [Int], left: Int, right: Int) -> Int {
         // 以 nums[left] 作为基准数
@@ -270,7 +270,7 @@ comments: true
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-
+    
     // 哨兵划分
     fn partition(nums: []i32, left: usize, right: usize) usize {
         // 以 nums[left] 作为基准数
@@ -289,11 +289,11 @@ 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; 算法流程
@@ -461,7 +461,9 @@ comments: true
 
 ## 11.4.2. &nbsp; 算法特性
 
-**时间复杂度 $O(n \log n)$** ：平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。最差情况下，每轮哨兵划分操作都将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间，因此是“非稳定排序”。
+**时间复杂度 $O(n \log n)$** ：平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
+
+最差情况下，每轮哨兵划分操作都将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间，因此是“非稳定排序”。
 
 **空间复杂度 $O(n)$** ：输入数组完全倒序下，达到最差递归深度 $n$ 。由于未借助辅助数组空间，因此是“原地排序”。
 
@@ -497,7 +499,7 @@ comments: true
         else
             return right;
     }
-
+    
     /* 哨兵划分（三数取中值） */
     int partition(int[] nums, int left, int right) {
         // 选取三个候选元素的中位数
@@ -532,7 +534,7 @@ comments: true
         else
             return right;
     }
-
+    
     /* 哨兵划分（三数取中值） */
     int partition(vector<int>& nums, int left, int right) {
         // 选取三个候选元素的中位数
@@ -565,7 +567,7 @@ comments: true
         elif (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]):
             return mid
         return right
-
+    
     def partition(self, nums: list[int], left: int, right: int) -> int:
         """ 哨兵划分（三数取中值） """
         # 以 nums[left] 作为基准数
@@ -600,7 +602,7 @@ comments: true
         }
         return right
     }
-
+    
     /* 哨兵划分（三数取中值）*/
     func (q *quickSortMedian) partition(nums []int, left, right int) int {
         // 以 nums[left] 作为基准数
@@ -636,7 +638,7 @@ comments: true
         else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return mid;
         else return right;
     }
-
+    
     /* 哨兵划分（三数取中值） */
     partition(nums, left, right) {
         // 选取三个候选元素的中位数
@@ -670,7 +672,7 @@ comments: true
             return right;
         }
     }
-
+    
     /* 哨兵划分（三数取中值） */
     partition(nums: number[], left: number, right: number): number {
         // 选取三个候选元素的中位数
@@ -697,7 +699,7 @@ comments: true
 
     ```c title="quick_sort.c"
     [class]{quickSortMedian}-[func]{medianThree}
-
+    
     [class]{quickSortMedian}-[func]{partition}
     ```
 
@@ -716,7 +718,7 @@ comments: true
         else
             return right;
     }
-
+    
     /* 哨兵划分（三数取中值） */
     int partition(int[] nums, int left, int right)
     {
@@ -752,7 +754,7 @@ comments: true
             return right
         }
     }
-
+    
     /* 哨兵划分（三数取中值） */
     func partitionMedian(nums: inout [Int], left: Int, right: Int) -> Int {
         // 选取三个候选元素的中位数
@@ -778,7 +780,7 @@ comments: true
             return right;
         }
     }
-
+    
     // 哨兵划分（三数取中值）
     fn partition(nums: []i32, left: usize, right: usize) usize {
         // 选取三个候选元素的中位数

chapter_sorting/summary.md

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