From 31820449f549316b1bcc0b116b8dfe1262f04551 Mon Sep 17 00:00:00 2001
From: krahets <krahets@163.com>
Date: Wed, 24 May 2023 00:32:38 +0800
Subject: [PATCH] build

---
 .../time_complexity.md                        |  40 ++---
 .../searching_algorithm_revisited.md          |   2 +-
 chapter_sorting/bubble_sort.md                | 117 +++++++------
 chapter_sorting/bucket_sort.md                |  19 +--
 chapter_sorting/counting_sort.md              |  18 +-
 chapter_sorting/insertion_sort.md             | 123 ++++++-------
 chapter_sorting/merge_sort.md                 |  16 +-
 chapter_sorting/quick_sort.md                 |  64 ++++---
 chapter_sorting/radix_sort.md                 |  14 +-
 chapter_sorting/selection_sort.md             | 161 ++++++++++++++++++
 chapter_sorting/summary.md                    |   4 +-
 11 files changed, 363 insertions(+), 215 deletions(-)
 create mode 100644 chapter_sorting/selection_sort.md

diff --git a/chapter_computational_complexity/time_complexity.md b/chapter_computational_complexity/time_complexity.md
index 165cc6efc..d988d0553 100755
--- a/chapter_computational_complexity/time_complexity.md
+++ b/chapter_computational_complexity/time_complexity.md
@@ -1373,9 +1373,9 @@ $$
     /* 平方阶（冒泡排序） */
     int bubbleSort(int[] nums) {
         int count = 0; // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1396,9 +1396,9 @@ $$
     /* 平方阶（冒泡排序） */
     int bubbleSort(vector<int> &nums) {
         int count = 0; // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.size() - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1419,9 +1419,9 @@ $$
     def bubble_sort(nums: list[int]) -> int:
         """平方阶（冒泡排序）"""
         count = 0  # 计数器
-        # 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        # 外循环：未排序区间为 [0, i]
         for i in range(len(nums) - 1, 0, -1):
-            # 内循环：冒泡操作
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for j in range(i):
                 if nums[j] > nums[j + 1]:
                     # 交换 nums[j] 与 nums[j + 1]
@@ -1438,9 +1438,9 @@ $$
     /* 平方阶（冒泡排序） */
     func bubbleSort(nums []int) int {
         count := 0 // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i := len(nums) - 1; i > 0; i-- {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
             for j := 0; j < i; j++ {
                 if nums[j] > nums[j+1] {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1461,9 +1461,9 @@ $$
     /* 平方阶（冒泡排序） */
     function bubbleSort(nums) {
         let count = 0; // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (let i = nums.length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (let j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1484,9 +1484,9 @@ $$
     /* 平方阶（冒泡排序） */
     function bubbleSort(nums: number[]): number {
         let count = 0; // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (let i = nums.length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (let j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1507,9 +1507,9 @@ $$
     /* 平方阶（冒泡排序） */
     int bubbleSort(int *nums, int n) {
         int count = 0; // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = n - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1530,9 +1530,9 @@ $$
     /* 平方阶（冒泡排序） */
     int bubbleSort(int[] nums) {
         int count = 0;  // 计数器
-                        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.Length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1553,9 +1553,9 @@ $$
     /* 平方阶（冒泡排序） */
     func bubbleSort(nums: inout [Int]) -> Int {
         var count = 0 // 计数器
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i in stride(from: nums.count - 1, to: 0, by: -1) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for j in 0 ..< i {
                 if nums[j] > nums[j + 1] {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -1576,11 +1576,11 @@ $$
     // 平方阶（冒泡排序）
     fn bubbleSort(nums: []i32) i32 {
         var count: i32 = 0;  // 计数器 
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         var i: i32 = @intCast(i32, nums.len ) - 1;
         while (i > 0) : (i -= 1) {
             var j: usize = 0;
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             while (j < i) : (j += 1) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
diff --git a/chapter_searching/searching_algorithm_revisited.md b/chapter_searching/searching_algorithm_revisited.md
index af8addb64..91a8ea1df 100644
--- a/chapter_searching/searching_algorithm_revisited.md
+++ b/chapter_searching/searching_algorithm_revisited.md
@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 10.4. &nbsp; 搜索算法
+# 10.4. &nbsp; 重识搜索算法
 
 「搜索算法 Searching Algorithm」用于在数据结构（例如数组、链表、树或图）中搜索一个或一组满足特定条件的元素。
 
diff --git a/chapter_sorting/bubble_sort.md b/chapter_sorting/bubble_sort.md
index 91215f110..fc9aa9372 100755
--- a/chapter_sorting/bubble_sort.md
+++ b/chapter_sorting/bubble_sort.md
@@ -2,16 +2,14 @@
 comments: true
 ---
 
-# 11.2. &nbsp; 冒泡排序
+# 11.3. &nbsp; 冒泡排序
 
-「冒泡排序 Bubble Sort」的工作原理类似于泡泡在水中的浮动。在水中，较大的泡泡会最先浮到水面。
+「冒泡排序 Bubble Sort」通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。
 
-「冒泡操作」利用元素交换操作模拟了上述过程，具体做法为：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
-
-**在完成一次冒泡操作后，数组的最大元素已位于正确位置，接下来只需对剩余 $n - 1$ 个元素进行排序**。
+我们可以利用元素交换操作模拟上述过程：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
 
 === "<1>"
-    ![冒泡操作步骤](bubble_sort.assets/bubble_operation_step1.png)
+    ![利用元素交换操作模拟冒泡](bubble_sort.assets/bubble_operation_step1.png)
 
 === "<2>"
     ![bubble_operation_step2](bubble_sort.assets/bubble_operation_step2.png)
@@ -31,13 +29,14 @@ comments: true
 === "<7>"
     ![bubble_operation_step7](bubble_sort.assets/bubble_operation_step7.png)
 
-## 11.2.1. &nbsp; 算法流程
+## 11.3.1. &nbsp; 算法流程
 
-设输入数组长度为 $n$ ，整个冒泡排序的步骤为：
+设输入数组长度为 $n$ ，冒泡排序的步骤为：
 
-1. 完成第一轮「冒泡」后，数组的最大元素已位于正确位置，接下来只需对剩余 $n - 1$ 个元素进行排序；
-2. 对剩余 $n - 1$ 个元素执行冒泡操作，可将第二大元素交换至正确位置，因而待排序元素只剩 $n - 2$ 个；
-3. 如此类推，经过 $n - 1$ 轮冒泡操作，整个数组便完成排序；
+1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**，
+2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。
+3. 以此类推，经过 $n - 1$ 轮“冒泡”后，**前 $n - 1$ 大的元素都被交换至正确位置**。
+4. 仅剩的一个元素必定是最小元素，无需排序，因此数组排序完成。
 
 ![冒泡排序流程](bubble_sort.assets/bubble_sort_overview.png)
 
@@ -48,9 +47,9 @@ comments: true
     ```java title="bubble_sort.java"
     /* 冒泡排序 */
     void bubbleSort(int[] nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -68,9 +67,9 @@ comments: true
     ```cpp title="bubble_sort.cpp"
     /* 冒泡排序 */
     void bubbleSort(vector<int> &nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.size() - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -88,9 +87,9 @@ comments: true
     def bubble_sort(nums: list[int]) -> None:
         """冒泡排序"""
         n = len(nums)
-        # 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        # 外循环：未排序区间为 [0, i]
         for i in range(n - 1, 0, -1):
-            # 内循环：冒泡操作
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for j in range(i):
                 if nums[j] > nums[j + 1]:
                     # 交换 nums[j] 与 nums[j + 1]
@@ -102,9 +101,9 @@ comments: true
     ```go title="bubble_sort.go"
     /* 冒泡排序 */
     func bubbleSort(nums []int) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i := len(nums) - 1; i > 0; i-- {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
             for j := 0; j < i; j++ {
                 if nums[j] > nums[j+1] {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -120,9 +119,9 @@ comments: true
     ```javascript title="bubble_sort.js"
     /* 冒泡排序 */
     function bubbleSort(nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (let i = nums.length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (let j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -140,9 +139,9 @@ comments: true
     ```typescript title="bubble_sort.ts"
     /* 冒泡排序 */
     function bubbleSort(nums: number[]): void {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (let i = nums.length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (let j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -160,9 +159,9 @@ comments: true
     ```c title="bubble_sort.c"
     /* 冒泡排序 */
     void bubbleSort(int nums[], int size) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = 0; i < size - 1; i++) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < size - 1 - i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     int temp = nums[j];
@@ -179,9 +178,9 @@ comments: true
     ```csharp title="bubble_sort.cs"
     /* 冒泡排序 */
     void bubbleSort(int[] nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.Length - 1; i > 0; i--) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -199,9 +198,9 @@ comments: true
     ```swift title="bubble_sort.swift"
     /* 冒泡排序 */
     func bubbleSort(nums: inout [Int]) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i in stride(from: nums.count - 1, to: 0, by: -1) {
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for j in stride(from: 0, to: i, by: 1) {
                 if nums[j] > nums[j + 1] {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -219,11 +218,11 @@ comments: true
     ```zig title="bubble_sort.zig"
     // 冒泡排序
     fn bubbleSort(nums: []i32) void {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         var i: usize = nums.len - 1;
         while (i > 0) : (i -= 1) {
             var j: usize = 0;
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             while (j < i) : (j += 1) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -236,17 +235,9 @@ comments: true
     }
     ```
 
-## 11.2.2. &nbsp; 算法特性
+## 11.3.2. &nbsp; 效率优化
 
-**时间复杂度 $O(n^2)$** ：各轮冒泡遍历的数组长度依次为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ ，总和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。在引入下文的 `flag` 优化后，最佳时间复杂度可达到 $O(n)$ ，所以它是“自适应排序”。
-
-**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间，因此是“原地排序”。
-
-由于冒泡操作中遇到相等元素不交换，因此冒泡排序是“稳定排序”。
-
-## 11.2.3. &nbsp; 效率优化
-
-我们发现，如果某轮冒泡操作中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 `flag` 来监测这种情况，一旦出现就立即返回。
+我们发现，如果某轮“冒泡”中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 `flag` 来监测这种情况，一旦出现就立即返回。
 
 经过优化，冒泡排序的最差和平均时间复杂度仍为 $O(n^2)$ ；但当输入数组完全有序时，可达到最佳时间复杂度 $O(n)$ 。
 
@@ -255,10 +246,10 @@ comments: true
     ```java title="bubble_sort.java"
     /* 冒泡排序（标志优化） */
     void bubbleSortWithFlag(int[] nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.length - 1; i > 0; i--) {
             boolean flag = false; // 初始化标志位
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -279,10 +270,10 @@ comments: true
     ```cpp title="bubble_sort.cpp"
     /* 冒泡排序（标志优化）*/
     void bubbleSortWithFlag(vector<int> &nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.size() - 1; i > 0; i--) {
             bool flag = false; // 初始化标志位
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -303,10 +294,10 @@ comments: true
     def bubble_sort_with_flag(nums: list[int]) -> None:
         """冒泡排序（标志优化）"""
         n = len(nums)
-        # 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        # 外循环：未排序区间为 [0, i]
         for i in range(n - 1, 0, -1):
             flag = False  # 初始化标志位
-            # 内循环：冒泡操作
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for j in range(i):
                 if nums[j] > nums[j + 1]:
                     # 交换 nums[j] 与 nums[j + 1]
@@ -321,10 +312,10 @@ comments: true
     ```go title="bubble_sort.go"
     /* 冒泡排序（标志优化）*/
     func bubbleSortWithFlag(nums []int) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i := len(nums) - 1; i > 0; i-- {
             flag := false // 初始化标志位
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
             for j := 0; j < i; j++ {
                 if nums[j] > nums[j+1] {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -344,10 +335,10 @@ comments: true
     ```javascript title="bubble_sort.js"
     /* 冒泡排序（标志优化）*/
     function bubbleSortWithFlag(nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (let i = nums.length - 1; i > 0; i--) {
             let flag = false; // 初始化标志位
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (let j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -367,10 +358,10 @@ comments: true
     ```typescript title="bubble_sort.ts"
     /* 冒泡排序（标志优化）*/
     function bubbleSortWithFlag(nums: number[]): void {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (let i = nums.length - 1; i > 0; i--) {
             let flag = false; // 初始化标志位
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (let j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -390,10 +381,10 @@ comments: true
     ```c title="bubble_sort.c"
     /* 冒泡排序（标志优化）*/
     void bubbleSortWithFlag(int nums[], int size) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = 0; i < size - 1; i++) {
             bool flag = false;
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < size - 1 - i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     int temp = nums[j];
@@ -413,10 +404,10 @@ comments: true
     ```csharp title="bubble_sort.cs"
     /* 冒泡排序（标志优化）*/
     void bubbleSortWithFlag(int[] nums) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for (int i = nums.Length - 1; i > 0; i--) {
             bool flag = false; // 初始化标志位
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -436,7 +427,7 @@ comments: true
     ```swift title="bubble_sort.swift"
     /* 冒泡排序（标志优化）*/
     func bubbleSortWithFlag(nums: inout [Int]) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i in stride(from: nums.count - 1, to: 0, by: -1) {
             var flag = false // 初始化标志位
             for j in stride(from: 0, to: i, by: 1) {
@@ -460,12 +451,12 @@ comments: true
     ```zig title="bubble_sort.zig"
     // 冒泡排序（标志优化）
     fn bubbleSortWithFlag(nums: []i32) void {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         var i: usize = nums.len - 1;
         while (i > 0) : (i -= 1) {
             var flag = false;   // 初始化标志位
             var j: usize = 0;
-            // 内循环：冒泡操作
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
             while (j < i) : (j += 1) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
@@ -479,3 +470,9 @@ comments: true
         }
     }
     ```
+
+## 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$ 使用常数大小的额外空间。
+- **稳定排序**：由于在“冒泡”中遇到相等元素不交换。
diff --git a/chapter_sorting/bucket_sort.md b/chapter_sorting/bucket_sort.md
index 5e50dfe41..297bb67c2 100644
--- a/chapter_sorting/bucket_sort.md
+++ b/chapter_sorting/bucket_sort.md
@@ -2,13 +2,13 @@
 comments: true
 ---
 
-# 11.6. &nbsp; 桶排序
+# 11.7. &nbsp; 桶排序
 
 前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性水平。
 
 「桶排序 Bucket Sort」是分治思想的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
 
-## 11.6.1. &nbsp; 算法流程
+## 11.7.1. &nbsp; 算法流程
 
 考虑一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数。桶排序的流程如下：
 
@@ -289,17 +289,14 @@ comments: true
 
     桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。
 
-## 11.6.2. &nbsp; 算法特性
+## 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 + 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 + k)$ 、非原地排序** ：需要借助 $k$ 个桶和总共 $n$ 个元素的额外空间。
+- 桶排序是否稳定取决于排序桶内元素的算法是否稳定。
 
-在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 $O(n^2)$ 时间，因此是“自适应排序”。
-
-**空间复杂度 $O(n + k)$** ：需要借助 $k$ 个桶和总共 $n$ 个元素的额外空间，属于“非原地排序”。
-
-桶排序是否稳定取决于排序桶内元素的算法是否稳定。
-
-## 11.6.3. &nbsp; 如何实现平均分配
+## 11.7.3. &nbsp; 如何实现平均分配
 
 桶排序的时间复杂度理论上可以达到 $O(n)$ ，**关键在于将元素均匀分配到各个桶中**，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。
 
diff --git a/chapter_sorting/counting_sort.md b/chapter_sorting/counting_sort.md
index 330b1df1b..e183523f4 100644
--- a/chapter_sorting/counting_sort.md
+++ b/chapter_sorting/counting_sort.md
@@ -2,11 +2,11 @@
 comments: true
 ---
 
-# 11.7. &nbsp; 计数排序
+# 11.8. &nbsp; 计数排序
 
 「计数排序 Counting Sort」通过统计元素数量来实现排序，通常应用于整数数组。
 
-## 11.7.1. &nbsp; 简单实现
+## 11.8.1. &nbsp; 简单实现
 
 先来看一个简单的例子。给定一个长度为 $n$ 的数组 `nums` ，其中的元素都是“非负整数”。计数排序的整体流程如下：
 
@@ -269,7 +269,7 @@ comments: true
 
     从桶排序的角度看，我们可以将计数排序中的计数数组 `counter` 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
 
-## 11.7.2. &nbsp; 完整实现
+## 11.8.2. &nbsp; 完整实现
 
 细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如，输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
 
@@ -647,15 +647,13 @@ $$
     [class]{}-[func]{countingSort}
     ```
 
-## 11.7.3. &nbsp; 算法特性
+## 11.8.3. &nbsp; 算法特性
 
-**时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。
+- **时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。
+- **空间复杂度 $O(n + m)$ 、非原地排序** ：借助了长度分别为 $n$ 和 $m$ 的数组 `res` 和 `counter` 。
+- **稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现稳定排序。实际上，正序遍历 `nums` 也可以得到正确的排序结果，但结果是非稳定的。
 
-**空间复杂度 $O(n + m)$** ：借助了长度分别为 $n$ 和 $m$ 的数组 `res` 和 `counter` ，因此是“非原地排序”。
-
-**稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现“稳定排序”。实际上，正序遍历 `nums` 也可以得到正确的排序结果，但结果是“非稳定”的。
-
-## 11.7.4. &nbsp; 局限性
+## 11.8.4. &nbsp; 局限性
 
 看到这里，你也许会觉得计数排序非常巧妙，仅通过统计数量就可以实现高效的排序工作。然而，使用计数排序的前置条件相对较为严格。
 
diff --git a/chapter_sorting/insertion_sort.md b/chapter_sorting/insertion_sort.md
index 03688eed7..57a76acfb 100755
--- a/chapter_sorting/insertion_sort.md
+++ b/chapter_sorting/insertion_sort.md
@@ -2,23 +2,26 @@
 comments: true
 ---
 
-# 11.3. &nbsp; 插入排序
+# 11.4. &nbsp; 插入排序
 
-「插入排序 Insertion Sort」是一种基于数组插入操作的排序算法。具体来说，选择一个待排序的元素作为基准值 `base` ，将 `base` 与其左侧已排序区间的元素逐一比较大小，并将其插入到正确的位置。
+「插入排序 Insertion Sort」是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。
 
-回顾数组插入操作，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
+具体来说，我们在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。
+
+回忆数组的元素插入操作，设基准元素为 `base` ，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
 
 ![单次插入操作](insertion_sort.assets/insertion_operation.png)
 
 <p align="center"> Fig. 单次插入操作 </p>
 
-## 11.3.1. &nbsp; 算法流程
+## 11.4.1. &nbsp; 算法流程
 
 插入排序的整体流程如下：
 
-1. 首先，选取数组的第 2 个元素作为 `base` ，执行插入操作后，**数组的前 2 个元素已排序**。
-2. 接着，选取第 3 个元素作为 `base` ，执行插入操作后，**数组的前 3 个元素已排序**。
-3. 以此类推，在最后一轮中，选取数组尾元素作为 `base` ，执行插入操作后，**所有元素均已排序**。
+1. 初始状态下，数组的第 1 个元素已完成排序。
+2. 选取数组的第 2 个元素作为 `base` ，将其插入到正确位置后，**数组的前 2 个元素已排序**。
+3. 选取第 3 个元素作为 `base` ，将其插入到正确位置后，**数组的前 3 个元素已排序**。
+4. 以此类推，在最后一轮中，选取最后一个元素作为 `base` ，将其插入到正确位置后，**所有元素均已排序**。
 
 ![插入排序流程](insertion_sort.assets/insertion_sort_overview.png)
 
@@ -29,15 +32,15 @@ comments: true
     ```java title="insertion_sort.java"
     /* 插入排序 */
     void insertionSort(int[] nums) {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for (int i = 1; i < nums.length; i++) {
             int base = nums[i], j = i - 1;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 0 && nums[j] > base) {
-                nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
                 j--;
             }
-            nums[j + 1] = base;        // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base;        // 将 base 赋值到正确位置
         }
     }
     ```
@@ -47,15 +50,15 @@ comments: true
     ```cpp title="insertion_sort.cpp"
     /* 插入排序 */
     void insertionSort(vector<int> &nums) {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for (int i = 1; i < nums.size(); i++) {
             int base = nums[i], j = i - 1;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 0 && nums[j] > base) {
-                nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
                 j--;
             }
-            nums[j + 1] = base; // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base; // 将 base 赋值到正确位置
         }
     }
     ```
@@ -65,15 +68,15 @@ comments: true
     ```python title="insertion_sort.py"
     def insertion_sort(nums: list[int]) -> None:
         """插入排序"""
-        # 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        # 外循环：已排序区间为 [0, i-1]
         for i in range(1, len(nums)):
             base = nums[i]
             j = i - 1
-            # 内循环：将 base 插入到左边的正确位置
+            # 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
             while j >= 0 and nums[j] > base:
-                nums[j + 1] = nums[j]  # 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]  # 将 nums[j] 向右移动一位
                 j -= 1
-            nums[j + 1] = base  # 2. 将 base 赋值到正确位置
+            nums[j + 1] = base  # 将 base 赋值到正确位置
     ```
 
 === "Go"
@@ -81,16 +84,16 @@ comments: true
     ```go title="insertion_sort.go"
     /* 插入排序 */
     func insertionSort(nums []int) {
-        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        // 外循环：未排序区间为 [0, i]
         for i := 1; i < len(nums); i++ {
             base := nums[i]
             j := i - 1
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             for j >= 0 && nums[j] > base {
-                nums[j+1] = nums[j] // 1. 将 nums[j] 向右移动一位
+                nums[j+1] = nums[j] // 将 nums[j] 向右移动一位
                 j--
             }
-            nums[j+1] = base // 2. 将 base 赋值到正确位置
+            nums[j+1] = base // 将 base 赋值到正确位置
         }
     }
     ```
@@ -100,16 +103,16 @@ comments: true
     ```javascript title="insertion_sort.js"
     /* 插入排序 */
     function insertionSort(nums) {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for (let i = 1; i < nums.length; i++) {
             let base = nums[i],
                 j = i - 1;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 0 && nums[j] > base) {
-                nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
                 j--;
             }
-            nums[j + 1] = base; // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base; // 将 base 赋值到正确位置
         }
     }
     ```
@@ -119,16 +122,16 @@ comments: true
     ```typescript title="insertion_sort.ts"
     /* 插入排序 */
     function insertionSort(nums: number[]): void {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for (let i = 1; i < nums.length; i++) {
             const base = nums[i];
             let j = i - 1;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 0 && nums[j] > base) {
-                nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
                 j--;
             }
-            nums[j + 1] = base; // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base; // 将 base 赋值到正确位置
         }
     }
     ```
@@ -138,16 +141,16 @@ comments: true
     ```c title="insertion_sort.c"
     /* 插入排序 */
     void insertionSort(int nums[], int size) {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for (int i = 1; i < size; i++) {
             int base = nums[i], j = i - 1;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 0 && nums[j] > base) {
-                // 1. 将 nums[j] 向右移动一位
+                // 将 nums[j] 向右移动一位
                 nums[j + 1] = nums[j];
                 j--;
             }
-            // 2. 将 base 赋值到正确位置
+            // 将 base 赋值到正确位置
             nums[j + 1] = base;
         }
     }
@@ -158,15 +161,15 @@ comments: true
     ```csharp title="insertion_sort.cs"
     /* 插入排序 */
     void insertionSort(int[] nums) {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for (int i = 1; i < nums.Length; i++) {
             int bas = nums[i], j = i - 1;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 0 && nums[j] > bas) {
-                nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
                 j--;
             }
-            nums[j + 1] = bas;         // 2. 将 base 赋值到正确位置
+            nums[j + 1] = bas;         // 将 base 赋值到正确位置
         }
     }
     ```
@@ -176,16 +179,16 @@ comments: true
     ```swift title="insertion_sort.swift"
     /* 插入排序 */
     func insertionSort(nums: inout [Int]) {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         for i in stride(from: 1, to: nums.count, by: 1) {
             let base = nums[i]
             var j = i - 1
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while j >= 0, nums[j] > base {
-                nums[j + 1] = nums[j] // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位
                 j -= 1
             }
-            nums[j + 1] = base // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base // 将 base 赋值到正确位置
         }
     }
     ```
@@ -195,38 +198,36 @@ comments: true
     ```zig title="insertion_sort.zig"
     // 插入排序
     fn insertionSort(nums: []i32) void {
-        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        // 外循环：已排序元素数量为 1, 2, ..., n
         var i: usize = 1;
         while (i < nums.len) : (i += 1) {
             var base = nums[i];
             var j: usize = i;
-            // 内循环：将 base 插入到左边的正确位置
+            // 内循环：将 base 插入到已排序部分的正确位置
             while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
-                nums[j] = nums[j - 1];  // 1. 将 nums[j] 向右移动一位
+                nums[j] = nums[j - 1];  // 将 nums[j] 向右移动一位
             }
-            nums[j] = base;             // 2. 将 base 赋值到正确位置
+            nums[j] = base;             // 将 base 赋值到正确位置
         }
     }
     ```
 
-## 11.3.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(n^2)$ 、自适应排序** ：最差情况下，每次插入操作分别需要循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和得到 $\frac{(n - 1) n}{2}$ ，因此时间复杂度为 $O(n^2)$ 。在遇到有序数据时，插入操作会提前终止。当输入数组完全有序时，插入排序达到最佳时间复杂度 $O(n)$ 。
+- **空间复杂度 $O(1)$ 、原地排序** ：指针 $i$ , $j$ 使用常数大小的额外空间。
+- **稳定排序**：在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序。
 
-**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间，所以插入排序是“原地排序”。
+## 11.4.3. &nbsp; 插入排序优势
 
-在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序，因此是“稳定排序”。
+插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。
 
-## 11.3.3. &nbsp; 插入排序优势
+这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元计算操作数量起到决定性因素。
 
-回顾冒泡排序和插入排序的复杂度分析，两者的循环轮数都是 $\frac{(n - 1) n}{2}$ 。然而，它们之间存在以下差异：
+实际上，许多编程语言（例如 Java）的内置排序函数都采用了插入排序，大致思路为：对于长数组，采用基于分治的排序算法，例如快速排序；对于短数组，直接使用插入排序。
 
-- 冒泡操作基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；
-- 插入操作基于元素赋值实现，仅需 1 个单元操作；
+虽然冒泡排序、选择排序和插入排序的时间复杂度都为 $O(n^2)$ ，但在实际情况中，**插入排序的使用频率显著高于冒泡排序和选择排序**。这是因为：
 
-粗略估计下来，冒泡排序的计算开销约为插入排序的 3 倍，因此插入排序更受欢迎。实际上，许多编程语言（如 Java）的内置排序函数都采用了插入排序，大致思路为：
-
-- 对于长数组，采用基于分治的排序算法，例如「快速排序」，时间复杂度为 $O(n \log n)$ ；
-- 对于短数组，直接使用「插入排序」，时间复杂度为 $O(n^2)$ ；
-
-尽管插入排序的时间复杂度高于快速排序，**但在数据量较小的情况下，插入排序实际上更快**。这是因为在数据量较小时，复杂度中的常数项（即每轮中的单元操作数量）起主导作用。这个现象与「线性查找」和「二分查找」的情况相似。
+- 冒泡排序基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；插入排序基于元素赋值实现，仅需 1 个单元操作。因此，**冒泡排序的计算开销通常比插入排序更高**。
+- 选择排序在任何情况下的时间复杂度都为 $O(n^2)$ 。**如果给定一组部分有序的数据，插入排序通常比选择排序效率更高**。
+- 选择排序不稳定，无法应用于多级排序。
diff --git a/chapter_sorting/merge_sort.md b/chapter_sorting/merge_sort.md
index 577047849..c6008a537 100755
--- a/chapter_sorting/merge_sort.md
+++ b/chapter_sorting/merge_sort.md
@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.5. &nbsp; 归并排序
+# 11.6. &nbsp; 归并排序
 
 「归并排序 Merge Sort」基于分治思想实现排序，包含“划分”和“合并”两个阶段：
 
@@ -13,7 +13,7 @@ comments: true
 
 <p align="center"> Fig. 归并排序的划分与合并阶段 </p>
 
-## 11.5.1. &nbsp; 算法流程
+## 11.6.1. &nbsp; 算法流程
 
 “划分阶段”从顶至底递归地将数组从中点切为两个子数组，直至长度为 1 ；
 
@@ -533,15 +533,13 @@ comments: true
 - **在阅读代码时，需要特别注意各个变量的含义**。`nums` 的待合并区间为 `[left, right]` ，但由于 `tmp` 仅复制了 `nums` 该区间的元素，因此 `tmp` 对应区间为 `[0, right - left]` 。
 - 在比较 `tmp[i]` 和 `tmp[j]` 的大小时，**还需考虑子数组遍历完成后的索引越界问题**，即 `i > leftEnd` 和 `j > rightEnd` 的情况。索引越界的优先级是最高的，如果左子数组已经被合并完了，那么不需要继续比较，直接合并右子数组元素即可。
 
-## 11.5.2. &nbsp; 算法特性
+## 11.6.2. &nbsp; 算法特性
 
-**时间复杂度 $O(n \log n)$** ：划分产生高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，因此总体时间复杂度为 $O(n \log n)$ 。
+- **时间复杂度 $O(n \log n)$ 、非自适应排序** ：划分产生高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，因此总体时间复杂度为 $O(n \log n)$ 。
+- **空间复杂度 $O(n)$ 、非原地排序** ：递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。合并操作需要借助辅助数组实现，使用 $O(n)$ 大小的额外空间。
+- **稳定排序**：在合并过程中，相等元素的次序保持不变。
 
-**空间复杂度 $O(n)$** ：递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间；合并操作需要借助辅助数组实现，使用 $O(n)$ 大小的额外空间；因此是“非原地排序”。
-
-在合并过程中，相等元素的次序保持不变，因此归并排序是“稳定排序”。
-
-## 11.5.3. &nbsp; 链表排序 *
+## 11.6.3. &nbsp; 链表排序 *
 
 归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下：
 
diff --git a/chapter_sorting/quick_sort.md b/chapter_sorting/quick_sort.md
index e56b0cb14..75491bd34 100755
--- a/chapter_sorting/quick_sort.md
+++ b/chapter_sorting/quick_sort.md
@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 11.4. &nbsp; 快速排序
+# 11.5. &nbsp; 快速排序
 
 「快速排序 Quick Sort」是一种基于分治思想的排序算法，运行高效，应用广泛。
 
@@ -313,9 +313,9 @@ comments: true
     }
     ```
 
-## 11.4.1. &nbsp; 算法流程
+## 11.5.1. &nbsp; 算法流程
 
-1. 首先，对原数组执行一次「哨兵划分」，得到待排序的左子数组和右子数组；
+1. 首先，对原数组执行一次「哨兵划分」，得到未排序的左子数组和右子数组；
 2. 然后，对左子数组和右子数组分别递归执行「哨兵划分」；
 3. 持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序；
 
@@ -507,17 +507,13 @@ comments: true
     }
     ```
 
-## 11.4.2. &nbsp; 算法特性
+## 11.5.2. &nbsp; 算法特性
 
-**时间复杂度 $O(n \log n)$** ：在平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
+- **时间复杂度 $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)$ 栈帧空间。排序操作是在原数组上进行的，未借助额外数组。
+- **非稳定排序**：在哨兵划分的最后一步，基准数可能会被交换至相等元素的右侧。
 
-在最差情况下，每轮哨兵划分操作都将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间；因此快速排序是“自适应排序”。
-
-**空间复杂度 $O(n)$** ：在输入数组完全倒序的情况下，达到最差递归深度 $n$ 。由于未使用辅助数组，因此算法是“原地排序”。
-
-在哨兵划分的最后一步，基准数可能会被交换至相等元素的右侧，因此是“非稳定排序”。
-
-## 11.4.3. &nbsp; 快排为什么快？
+## 11.5.3. &nbsp; 快排为什么快？
 
 从名称上就能看出，快速排序在效率方面应该具有一定的优势。尽管快速排序的平均时间复杂度与「归并排序」和「堆排序」相同，但通常快速排序的效率更高，原因如下：
 
@@ -525,7 +521,7 @@ comments: true
 - **缓存使用效率高**：在执行哨兵划分操作时，系统可将整个子数组加载到缓存，因此访问元素的效率较高。而像「堆排序」这类算法需要跳跃式访问元素，从而缺乏这一特性。
 - **复杂度的常数系数低**：在上述三种算法中，快速排序的比较、赋值、交换等操作的总数量最少。这与「插入排序」比「冒泡排序」更快的原因类似。
 
-## 11.4.4. &nbsp; 基准数优化
+## 11.5.4. &nbsp; 基准数优化
 
 **快速排序在某些输入下的时间效率可能降低**。举一个极端例子，假设输入数组是完全倒序的，由于我们选择最左端元素作为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，导致左子数组长度为 $n - 1$ 、右子数组长度为 $0$ 。如此递归下去，每轮哨兵划分后的右子数组长度都为 $0$ ，分治策略失效，快速排序退化为「冒泡排序」。
 
@@ -908,7 +904,7 @@ comments: true
     }
     ```
 
-## 11.4.5. &nbsp; 尾递归优化
+## 11.5.5. &nbsp; 尾递归优化
 
 **在某些输入下，快速排序可能占用空间较多**。以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 $0$ ，递归树的高度会达到 $n - 1$ ，此时需要占用 $O(n)$ 大小的栈帧空间。
 
@@ -926,10 +922,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 quickSort(nums, left, pivot - 1); // 递归排序左子数组
-                left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 quickSort(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -947,10 +943,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 quickSort(nums, left, pivot - 1); // 递归排序左子数组
-                left = pivot + 1;                 // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1;                 // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 quickSort(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1;                 // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1;                 // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -968,10 +964,10 @@ comments: true
             # 对两个子数组中较短的那个执行快排
             if pivot - left < right - pivot:
                 self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
-                left = pivot + 1  # 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1  # 剩余未排序区间为 [pivot + 1, right]
             else:
                 self.quick_sort(nums, pivot + 1, right)  # 递归排序右子数组
-                right = pivot - 1  # 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1  # 剩余未排序区间为 [left, pivot - 1]
     ```
 
 === "Go"
@@ -986,10 +982,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if pivot-left < right-pivot {
                 q.quickSort(nums, left, pivot-1) // 递归排序左子数组
-                left = pivot + 1                 // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1                 // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 q.quickSort(nums, pivot+1, right) // 递归排序右子数组
-                right = pivot - 1                 // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1                 // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -1007,10 +1003,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
-                left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -1028,10 +1024,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
-                left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -1050,10 +1046,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组
-                left = pivot + 1;                         // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1;                         // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1;                         // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1;                         // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -1071,10 +1067,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 quickSort(nums, left, pivot - 1);  // 递归排序左子数组
-                left = pivot + 1;  // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1;  // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 quickSort(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -1094,10 +1090,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left) < (right - pivot) {
                 quickSortTailCall(nums: &nums, left: left, right: pivot - 1) // 递归排序左子数组
-                left = pivot + 1 // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1 // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 quickSortTailCall(nums: &nums, left: pivot + 1, right: right) // 递归排序右子数组
-                right = pivot - 1 // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1 // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -1117,10 +1113,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
                 quickSort(nums, left, pivot - 1);   // 递归排序左子数组
-                left = pivot + 1;                   // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1;                   // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 quickSort(nums, pivot + 1, right);  // 递归排序右子数组
-                right = pivot - 1;                  // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1;                  // 剩余未排序区间为 [left, pivot - 1]
             }
         }
     }
diff --git a/chapter_sorting/radix_sort.md b/chapter_sorting/radix_sort.md
index f1c66bd90..9e8e4c4dc 100644
--- a/chapter_sorting/radix_sort.md
+++ b/chapter_sorting/radix_sort.md
@@ -2,13 +2,13 @@
 comments: true
 ---
 
-# 11.8. &nbsp; 基数排序
+# 11.9. &nbsp; 基数排序
 
 上一节我们介绍了计数排序，它适用于数据量 $n$ 较大但数据范围 $m$ 较小的情况。假设我们需要对 $n = 10^6$ 个学号进行排序，而学号是一个 $8$ 位数字，这意味着数据范围 $m = 10^8$ 非常大，使用计数排序需要分配大量内存空间，而基数排序可以避免这种情况。
 
 「基数排序 Radix Sort」的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。
 
-## 11.8.1. &nbsp; 算法流程
+## 11.9.1. &nbsp; 算法流程
 
 以学号数据为例，假设数字的最低位是第 $1$ 位，最高位是第 $8$ 位，基数排序的步骤如下：
 
@@ -587,10 +587,10 @@ $$
 
     在连续的排序轮次中，后一轮排序会覆盖前一轮排序的结果。举例来说，如果第一轮排序结果 $a < b$ ，而第二轮排序结果 $a > b$ ，那么第二轮的结果将取代第一轮的结果。由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。
 
-## 11.8.2. &nbsp; 算法特性
+## 11.9.2. &nbsp; 算法特性
 
-**时间复杂度 $O(nk)$** ：设数据量为 $n$ 、数据为 $d$ 进制、最大位数为 $k$ ，则对某一位执行计数排序使用 $O(n + d)$ 时间，排序所有 $k$ 位使用 $O((n + d)k)$ 时间。通常情况下，$d$ 和 $k$ 都相对较小，时间复杂度趋向 $O(n)$ 。
+相较于计数排序，基数排序适用于数值范围较大的情况，**但前提是数据必须可以表示为固定位数的格式，且位数不能过大**。例如，浮点数不适合使用基数排序，因为其位数 $k$ 过大，可能导致时间复杂度 $O(nk) \gg O(n^2)$ 。
 
-**空间复杂度 $O(n + d)$** ：与计数排序相同，基数排序需要借助长度为 $n$ 和 $d$ 的数组 `res` 和 `counter` ，因此它是一种“非原地排序”。
-
-基数排序与计数排序一样，都属于稳定排序。相较于计数排序，基数排序适用于数值范围较大的情况，**但前提是数据必须可以表示为固定位数的格式，且位数不能过大**。例如，浮点数不适合使用基数排序，因为其位数 $k$ 过大，可能导致时间复杂度 $O(nk) \gg O(n^2)$ 。
+- **时间复杂度 $O(nk)$** ：设数据量为 $n$ 、数据为 $d$ 进制、最大位数为 $k$ ，则对某一位执行计数排序使用 $O(n + d)$ 时间，排序所有 $k$ 位使用 $O((n + d)k)$ 时间。通常情况下，$d$ 和 $k$ 都相对较小，时间复杂度趋向 $O(n)$ 。
+- **空间复杂度 $O(n + d)$ 、非原地排序** ：与计数排序相同，基数排序需要借助长度为 $n$ 和 $d$ 的数组 `res` 和 `counter` 。
+- **稳定排序**：与计数排序相同。
diff --git a/chapter_sorting/selection_sort.md b/chapter_sorting/selection_sort.md
new file mode 100644
index 000000000..a075d1b8d
--- /dev/null
+++ b/chapter_sorting/selection_sort.md
@@ -0,0 +1,161 @@
+---
+comments: true
+---
+
+# 11.2. &nbsp; 选择排序
+
+「选择排序 Insertion Sort」的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。完整步骤如下：
+
+1. 初始状态下，所有元素未排序，即未排序（索引）区间为 $[0, n-1]$ 。
+2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。
+3. 选取区间 $[1, n-1]$ 中的最小元素，将其与索引 $1$ 处元素交换。完成后，数组前 2 个元素已排序。
+4. 以此类推。经过 $n - 1$ 轮选择与交换后，数组前 $n - 1$ 个元素已排序。
+5. 仅剩的一个元素必定是最大元素，无需排序，因此数组排序完成。
+
+=== "<1>"
+    ![选择排序步骤](selection_sort.assets/selection_sort_step1.png)
+
+=== "<2>"
+    ![selection_sort_step2](selection_sort.assets/selection_sort_step2.png)
+
+=== "<3>"
+    ![selection_sort_step3](selection_sort.assets/selection_sort_step3.png)
+
+=== "<4>"
+    ![selection_sort_step4](selection_sort.assets/selection_sort_step4.png)
+
+=== "<5>"
+    ![selection_sort_step5](selection_sort.assets/selection_sort_step5.png)
+
+=== "<6>"
+    ![selection_sort_step6](selection_sort.assets/selection_sort_step6.png)
+
+=== "<7>"
+    ![selection_sort_step7](selection_sort.assets/selection_sort_step7.png)
+
+=== "<8>"
+    ![selection_sort_step8](selection_sort.assets/selection_sort_step8.png)
+
+=== "<9>"
+    ![selection_sort_step9](selection_sort.assets/selection_sort_step9.png)
+
+=== "<10>"
+    ![selection_sort_step10](selection_sort.assets/selection_sort_step10.png)
+
+=== "<11>"
+    ![selection_sort_step11](selection_sort.assets/selection_sort_step11.png)
+
+在代码中，我们用 $k$ 来记录未排序区间内的最小元素。
+
+=== "Java"
+
+    ```java title="selection_sort.java"
+    /* 选择排序 */
+    void selectionSort(int[] nums) {
+        int n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间 [i, n-1] 中的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k]) {
+                    k = j; // 更新最小元素
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="selection_sort.cpp"
+    /* 选择排序 */
+    void selectionSort(vector<int> &nums) {
+        int n = nums.size();
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间 [i, n-1] 中的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k]) {
+                    k = j; // 更新最小元素
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            swap(nums[i], nums[k]);
+        }
+    }
+    ```
+
+=== "Python"
+
+    ```python title="selection_sort.py"
+    def selection_sort(nums: list[int]):
+        """选择排序"""
+        n = len(nums)
+        # 外循环：未排序区间为 [i, n-1]
+        for i in range(n - 1):
+            # 内循环：找到未排序区间 [i, n-1] 中的最小元素
+            k = i
+            for j in range(i + 1, n):
+                if nums[j] < nums[k]:
+                    k = j  # 更新最小元素
+            # 将该最小元素与未排序区间的首个元素交换
+            nums[i], nums[k] = nums[k], nums[i]
+    ```
+
+=== "Go"
+
+    ```go title="selection_sort.go"
+    [class]{}-[func]{selectionSort}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="selection_sort.js"
+    [class]{}-[func]{selectionSort}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="selection_sort.ts"
+    [class]{}-[func]{selectionSort}
+    ```
+
+=== "C"
+
+    ```c title="selection_sort.c"
+    [class]{}-[func]{selectionSort}
+    ```
+
+=== "C#"
+
+    ```csharp title="selection_sort.cs"
+    [class]{selection_sort}-[func]{selectionSort}
+    ```
+
+=== "Swift"
+
+    ```swift title="selection_sort.swift"
+    [class]{}-[func]{selectionSort}
+    ```
+
+=== "Zig"
+
+    ```zig title="selection_sort.zig"
+    [class]{}-[func]{selectionSort}
+    ```
+
+## 11.2.1. &nbsp; 算法特性
+
+- **时间复杂度为 $O(n^2)$ 、非自适应排序**：共有 $n - 1$ 轮外循环，分别包含 $n$ , $n - 1$ , $\cdots$ , $2$ , $2$ 轮内循环，求和为 $\frac{(n - 1)(n + 2)}{2}$ 。
+- **空间复杂度 $O(1)$ 、原地排序**：指针 $i$ , $j$ 使用常数大小的额外空间。
+- **非稳定排序**：在交换元素时，有可能将 `nums[i]` 交换至其相等元素的右边，导致两者的相对顺序发生改变。
+
+![选择排序非稳定示例](selection_sort.assets/selection_sort_step11.png)
+
+<p align="center"> Fig. 选择排序非稳定示例 </p>
diff --git a/chapter_sorting/summary.md b/chapter_sorting/summary.md
index e94c2fbe0..4ee0df32f 100644
--- a/chapter_sorting/summary.md
+++ b/chapter_sorting/summary.md
@@ -2,10 +2,10 @@
 comments: true
 ---
 
-# 11.9. &nbsp; 小结
+# 11.10. &nbsp; 小结
 
 - 冒泡排序通过交换相邻元素来实现排序。通过添加一个标志位来实现提前返回，我们可以将冒泡排序的最佳时间复杂度优化到 $O(n)$ 。
-- 插入排序每轮将待排序区间内的元素插入到已排序区间的正确位置，从而完成排序。虽然插入排序的时间复杂度为 $O(n^2)$ ，但由于单元操作相对较少，它在小数据量的排序任务中非常受欢迎。
+- 插入排序每轮将未排序区间内的元素插入到已排序区间的正确位置，从而完成排序。虽然插入排序的时间复杂度为 $O(n^2)$ ，但由于单元操作相对较少，它在小数据量的排序任务中非常受欢迎。
 - 快速排序基于哨兵划分操作实现排序。在哨兵划分中，有可能每次都选取到最差的基准数，导致时间复杂度劣化至 $O(n^2)$ 。引入中位数基准数或随机基准数可以降低这种劣化的概率。尾递归方法可以有效地减少递归深度，将空间复杂度优化到 $O(\log n)$ 。
 - 归并排序包括划分和合并两个阶段，典型地体现了分治策略。在归并排序中，排序数组需要创建辅助数组，空间复杂度为 $O(n)$ ；然而排序链表的空间复杂度可以优化至 $O(1)$ 。
 - 桶排序包含三个步骤：数据分桶、桶内排序和合并结果。它同样体现了分治策略，适用于数据体量很大的情况。桶排序的关键在于对数据进行平均分配。