build

chapter_sorting/bubble_sort.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.3.   冒泡排序
+# 11.3   冒泡排序
 
 「冒泡排序 Bubble Sort」通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。
 
@@ -31,7 +31,7 @@ comments: true
 
 <p align="center"> 图：利用元素交换操作模拟冒泡 </p>
 
-## 11.3.1. &nbsp; 算法流程
+## 11.3.1 &nbsp; 算法流程
 
 设数组的长度为 $n$ ，冒泡排序的步骤为：
 
@@ -277,7 +277,7 @@ comments: true
     }
     ```
 
-## 11.3.2. &nbsp; 效率优化
+## 11.3.2 &nbsp; 效率优化
 
 我们发现，如果某轮“冒泡”中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 `flag` 来监测这种情况，一旦出现就立即返回。
 
@@ -559,7 +559,7 @@ comments: true
     }
     ```
 
-## 11.3.3. &nbsp; 算法特性
+## 11.3.3 &nbsp; 算法特性
 
 - **时间复杂度为 $O(n^2)$ 、自适应排序** ：各轮“冒泡”遍历的数组长度依次为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ ，总和为 $\frac{(n - 1) n}{2}$ 。在引入 `flag` 优化后，最佳时间复杂度可达到 $O(n)$ 。
 - **空间复杂度为 $O(1)$ 、原地排序**：指针 $i$ , $j$ 使用常数大小的额外空间。

chapter_sorting/bucket_sort.md

@@ -2,13 +2,13 @@
 comments: true
 ---
 
-# 11.8.   桶排序
+# 11.8   桶排序
 
 前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性阶。
 
 「桶排序 Bucket Sort」是分治思想的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
 
-## 11.8.1.   算法流程
+## 11.8.1   算法流程
 
 考虑一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数。桶排序的流程如下：
 
@@ -396,14 +396,14 @@ comments: true
 
     桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。
 
-## 11.8.2.   算法特性
+## 11.8.2   算法特性
 
 - **时间复杂度 $O(n + k)$** ：假设元素在各个桶内平均分布，那么每个桶内的元素数量为 $\frac{n}{k}$ 。假设排序单个桶使用 $O(\frac{n}{k} \log\frac{n}{k})$ 时间，则排序所有桶使用 $O(n \log\frac{n}{k})$ 时间。**当桶数量 $k$ 比较大时，时间复杂度则趋向于 $O(n)$** 。合并结果时需要遍历所有桶和元素，花费 $O(n + k)$ 时间。
 - **自适应排序**：在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 $O(n^2)$ 时间。
 - **空间复杂度 $O(n + k)$ 、非原地排序** ：需要借助 $k$ 个桶和总共 $n$ 个元素的额外空间。
 - 桶排序是否稳定取决于排序桶内元素的算法是否稳定。
 
-## 11.8.3.   如何实现平均分配
+## 11.8.3   如何实现平均分配
 
 桶排序的时间复杂度理论上可以达到 $O(n)$ ，**关键在于将元素均匀分配到各个桶中**，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。
 

chapter_sorting/counting_sort.md

@@ -2,11 +2,11 @@
 comments: true
 ---
 
-# 11.9.   计数排序
+# 11.9   计数排序
 
 「计数排序 Counting Sort」通过统计元素数量来实现排序，通常应用于整数数组。
 
-## 11.9.1.   简单实现
+## 11.9.1   简单实现
 
 先来看一个简单的例子。给定一个长度为 $n$ 的数组 `nums` ，其中的元素都是“非负整数”。计数排序的整体流程如下：
 
@@ -321,7 +321,7 @@ comments: true
 
     从桶排序的角度看，我们可以将计数排序中的计数数组 `counter` 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
 
-## 11.9.2.   完整实现
+## 11.9.2   完整实现
 
 细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如，输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
 
@@ -772,13 +772,13 @@ $$
     }
     ```
 
-## 11.9.3.   算法特性
+## 11.9.3   算法特性
 
 - **时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。
 - **空间复杂度 $O(n + m)$ 、非原地排序** ：借助了长度分别为 $n$ 和 $m$ 的数组 `res` 和 `counter` 。
 - **稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现稳定排序。实际上，正序遍历 `nums` 也可以得到正确的排序结果，但结果是非稳定的。
 
-## 11.9.4.   局限性
+## 11.9.4   局限性
 
 看到这里，你也许会觉得计数排序非常巧妙，仅通过统计数量就可以实现高效的排序工作。然而，使用计数排序的前置条件相对较为严格。
 

chapter_sorting/heap_sort.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.7.   堆排序
+# 11.7   堆排序
 
 !!! tip
 
@@ -15,7 +15,7 @@ comments: true
 
 以上方法虽然可行，但需要借助一个额外数组来保存弹出的元素，比较浪费空间。在实际中，我们通常使用一种更加优雅的实现方式。
 
-## 11.7.1.   算法流程
+## 11.7.1   算法流程
 
 设数组的长度为 $n$ ，堆排序的流程如下：
 
@@ -540,7 +540,7 @@ comments: true
     }
     ```
 
-## 11.7.2.   算法特性
+## 11.7.2   算法特性
 
 - **时间复杂度 $O(n \log n)$ 、非自适应排序** ：建堆操作使用 $O(n)$ 时间。从堆中提取最大元素的时间复杂度为 $O(\log n)$ ，共循环 $n - 1$ 轮。
 - **空间复杂度 $O(1)$ 、原地排序** ：几个指针变量使用 $O(1)$ 空间。元素交换和堆化操作都是在原数组上进行的。

chapter_sorting/index.md

@@ -3,7 +3,7 @@ comments: true
 icon: material/sort-ascending
 ---
 
-# 11.   排序
+# 第 11 章   排序
 
 <div class="center-table" markdown>
 

chapter_sorting/insertion_sort.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.4.   插入排序
+# 11.4   插入排序
 
 「插入排序 Insertion Sort」是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。
 
@@ -14,7 +14,7 @@ comments: true
 
 <p align="center"> 图：单次插入操作 </p>
 
-## 11.4.1. &nbsp; 算法流程
+## 11.4.1 &nbsp; 算法流程
 
 插入排序的整体流程如下：
 
@@ -248,13 +248,13 @@ comments: true
     }
     ```
 
-## 11.4.2. &nbsp; 算法特性
+## 11.4.2 &nbsp; 算法特性
 
 - **时间复杂度 $O(n^2)$ 、自适应排序** ：最差情况下，每次插入操作分别需要循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和得到 $\frac{(n - 1) n}{2}$ ，因此时间复杂度为 $O(n^2)$ 。在遇到有序数据时，插入操作会提前终止。当输入数组完全有序时，插入排序达到最佳时间复杂度 $O(n)$ 。
 - **空间复杂度 $O(1)$ 、原地排序** ：指针 $i$ , $j$ 使用常数大小的额外空间。
 - **稳定排序**：在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序。
 
-## 11.4.3. &nbsp; 插入排序优势
+## 11.4.3 &nbsp; 插入排序优势
 
 插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。
 

chapter_sorting/merge_sort.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.6.   归并排序
+# 11.6   归并排序
 
 「归并排序 Merge Sort」基于分治思想实现排序，包含“划分”和“合并”两个阶段：
 
@@ -13,7 +13,7 @@ comments: true
 
 <p align="center"> 图：归并排序的划分与合并阶段 </p>
 
-## 11.6.1. &nbsp; 算法流程
+## 11.6.1 &nbsp; 算法流程
 
 “划分阶段”从顶至底递归地将数组从中点切为两个子数组：
 
@@ -625,13 +625,13 @@ comments: true
 - **在阅读代码时，需要特别注意各个变量的含义**。`nums` 的待合并区间为 `[left, right]` ，但由于 `tmp` 仅复制了 `nums` 该区间的元素，因此 `tmp` 对应区间为 `[0, right - left]` 。
 - 在比较 `tmp[i]` 和 `tmp[j]` 的大小时，**还需考虑子数组遍历完成后的索引越界问题**，即 `i > leftEnd` 和 `j > rightEnd` 的情况。索引越界的优先级是最高的，如果左子数组已经被合并完了，那么不需要继续比较，直接合并右子数组元素即可。
 
-## 11.6.2. &nbsp; 算法特性
+## 11.6.2 &nbsp; 算法特性
 
 - **时间复杂度 $O(n \log n)$ 、非自适应排序** ：划分产生高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，因此总体时间复杂度为 $O(n \log n)$ 。
 - **空间复杂度 $O(n)$ 、非原地排序** ：递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。合并操作需要借助辅助数组实现，使用 $O(n)$ 大小的额外空间。
 - **稳定排序**：在合并过程中，相等元素的次序保持不变。
 
-## 11.6.3. &nbsp; 链表排序 *
+## 11.6.3 &nbsp; 链表排序 *
 
 归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下：
 

chapter_sorting/quick_sort.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.5.   快速排序
+# 11.5   快速排序
 
 「快速排序 Quick Sort」是一种基于分治思想的排序算法，运行高效，应用广泛。
 
@@ -360,7 +360,7 @@ comments: true
     }
     ```
 
-## 11.5.1.   算法流程
+## 11.5.1   算法流程
 
 1. 首先，对原数组执行一次「哨兵划分」，得到未排序的左子数组和右子数组。
 2. 然后，对左子数组和右子数组分别递归执行「哨兵划分」。
@@ -586,13 +586,13 @@ comments: true
     }
     ```
 
-## 11.5.2.   算法特性
+## 11.5.2   算法特性
 
 - **时间复杂度 $O(n \log n)$ 、自适应排序** ：在平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。在最差情况下，每轮哨兵划分操作都将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间。
 - **空间复杂度 $O(n)$ 、原地排序** ：在输入数组完全倒序的情况下，达到最差递归深度 $n$ ，使用 $O(n)$ 栈帧空间。排序操作是在原数组上进行的，未借助额外数组。
 - **非稳定排序**：在哨兵划分的最后一步，基准数可能会被交换至相等元素的右侧。
 
-## 11.5.3.   快排为什么快？
+## 11.5.3   快排为什么快？
 
 从名称上就能看出，快速排序在效率方面应该具有一定的优势。尽管快速排序的平均时间复杂度与「归并排序」和「堆排序」相同，但通常快速排序的效率更高，原因如下：
 
@@ -600,7 +600,7 @@ comments: true
 - **缓存使用效率高**：在执行哨兵划分操作时，系统可将整个子数组加载到缓存，因此访问元素的效率较高。而像「堆排序」这类算法需要跳跃式访问元素，从而缺乏这一特性。
 - **复杂度的常数系数低**：在上述三种算法中，快速排序的比较、赋值、交换等操作的总数量最少。这与「插入排序」比「冒泡排序」更快的原因类似。
 
-## 11.5.4.   基准数优化
+## 11.5.4   基准数优化
 
 **快速排序在某些输入下的时间效率可能降低**。举一个极端例子，假设输入数组是完全倒序的，由于我们选择最左端元素作为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，导致左子数组长度为 $n - 1$ 、右子数组长度为 $0$ 。如此递归下去，每轮哨兵划分后的右子数组长度都为 $0$ ，分治策略失效，快速排序退化为「冒泡排序」。
 
@@ -1053,7 +1053,7 @@ comments: true
     }
     ```
 
-## 11.5.5.   尾递归优化
+## 11.5.5   尾递归优化
 
 **在某些输入下，快速排序可能占用空间较多**。以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 $0$ ，递归树的高度会达到 $n - 1$ ，此时需要占用 $O(n)$ 大小的栈帧空间。
 

chapter_sorting/radix_sort.md

@@ -2,13 +2,13 @@
 comments: true
 ---
 
-# 11.10.   基数排序
+# 11.10   基数排序
 
 上一节我们介绍了计数排序，它适用于数据量 $n$ 较大但数据范围 $m$ 较小的情况。假设我们需要对 $n = 10^6$ 个学号进行排序，而学号是一个 $8$ 位数字，这意味着数据范围 $m = 10^8$ 非常大，使用计数排序需要分配大量内存空间，而基数排序可以避免这种情况。
 
 「基数排序 Radix Sort」的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。
 
-## 11.10.1.   算法流程
+## 11.10.1   算法流程
 
 以学号数据为例，假设数字的最低位是第 $1$ 位，最高位是第 $8$ 位，基数排序的步骤如下：
 
@@ -688,7 +688,7 @@ $$
 
     在连续的排序轮次中，后一轮排序会覆盖前一轮排序的结果。举例来说，如果第一轮排序结果 $a < b$ ，而第二轮排序结果 $a > b$ ，那么第二轮的结果将取代第一轮的结果。由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。
 
-## 11.10.2. &nbsp; 算法特性
+## 11.10.2 &nbsp; 算法特性
 
 相较于计数排序，基数排序适用于数值范围较大的情况，**但前提是数据必须可以表示为固定位数的格式，且位数不能过大**。例如，浮点数不适合使用基数排序，因为其位数 $k$ 过大，可能导致时间复杂度 $O(nk) \gg O(n^2)$ 。
 

chapter_sorting/selection_sort.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.2.   选择排序
+# 11.2   选择排序
 
 「选择排序 Selection Sort」的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。
 
@@ -284,7 +284,7 @@ comments: true
     }
     ```
 
-## 11.2.1.   算法特性
+## 11.2.1   算法特性
 
 - **时间复杂度为 $O(n^2)$ 、非自适应排序**：外循环共 $n - 1$ 轮，第一轮的未排序区间长度为 $n$ ，最后一轮的未排序区间长度为 $2$ ，即各轮外循环分别包含 $n$ , $n - 1$ , $\cdots$ , $2$ 轮内循环，求和为 $\frac{(n - 1)(n + 2)}{2}$ 。
 - **空间复杂度 $O(1)$ 、原地排序**：指针 $i$ , $j$ 使用常数大小的额外空间。

chapter_sorting/sorting_algorithm.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.1.   排序算法
+# 11.1   排序算法
 
 「排序算法 Sorting Algorithm」用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更有效地查找、分析和处理。
 
@@ -12,7 +12,7 @@ comments: true
 
 <p align="center"> 图：数据类型和判断规则示例 </p>
 
-## 11.1.1. &nbsp; 评价维度
+## 11.1.1 &nbsp; 评价维度
 
 **运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
 
@@ -47,7 +47,7 @@ comments: true
 
 **是否基于比较**：「基于比较的排序」依赖于比较运算符（$<$ , $=$ , $>$）来判断元素的相对顺序，从而排序整个数组，理论最优时间复杂度为 $O(n \log n)$ 。而「非比较排序」不使用比较运算符，时间复杂度可达 $O(n)$ ，但其通用性相对较差。
 
-## 11.1.2. &nbsp; 理想排序算法
+## 11.1.2 &nbsp; 理想排序算法
 
 **运行快、原地、稳定、正向自适应、通用性好**。显然，迄今为止尚未发现兼具以上所有特性的排序算法。因此，在选择排序算法时，需要根据具体的数据特点和问题需求来决定。
 

chapter_sorting/summary.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.11.   小结
+# 11.11   小结
 
 - 冒泡排序通过交换相邻元素来实现排序。通过添加一个标志位来实现提前返回，我们可以将冒泡排序的最佳时间复杂度优化到 $O(n)$ 。
 - 插入排序每轮将未排序区间内的元素插入到已排序区间的正确位置，从而完成排序。虽然插入排序的时间复杂度为 $O(n^2)$ ，但由于单元操作相对较少，它在小数据量的排序任务中非常受欢迎。
@@ -17,7 +17,7 @@ comments: true
 
 <p align="center"> 图：排序算法对比 </p>
 
-## 11.11.1. &nbsp; Q & A
+## 11.11.1 &nbsp; Q & A
 
 !!! question "排序算法稳定性在什么情况下是必须的？"