build

chapter_sorting/bubble_sort.md

@@ -228,7 +228,23 @@ comments: true
 === "Zig"
 
     ```zig title="bubble_sort.zig"
-
+    // 冒泡排序
+    fn bubbleSort(nums: []i32) void {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var j: usize = 0;
+            // 内循环：冒泡操作
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 ## 11.2.2. 算法特性
@@ -461,5 +477,24 @@ comments: true
 === "Zig"
 
     ```zig title="bubble_sort.zig"
-
+    // 冒泡排序（标志优化）
+    fn bubbleSortWithFlag(nums: []i32) void {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var flag = false;   // 初始化标志位
+            var j: usize = 0;
+            // 内循环：冒泡操作
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;
+                }
+            }
+            if (!flag) break;   // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```

chapter_sorting/insertion_sort.md

@@ -197,7 +197,20 @@ comments: true
 === "Zig"
 
     ```zig title="insertion_sort.zig"
-
+    // 插入排序
+    fn insertionSort(nums: []i32) void {
+        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        var i: usize = 1;
+        while (i < nums.len) : (i += 1) {
+            var base = nums[i];
+            var j: usize = i;
+            // 内循环：将 base 插入到左边的正确位置
+            while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
+                nums[j] = nums[j - 1];  // 1. 将 nums[j] 向右移动一位
+            }
+            nums[j] = base;             // 2. 将 base 赋值到正确位置
+        }
+    }
     ```
 
 ## 11.3.2. 算法特性

chapter_sorting/quick_sort.md

@@ -262,7 +262,26 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
+    // 元素交换
+    fn swap(nums: []i32, i: usize, j: usize) void {
+        var tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
 
+    // 哨兵划分
+    fn partition(nums: []i32, left: usize, right: usize) usize {
+        // 以 nums[left] 作为基准数
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 从右向左找首个小于基准数的元素
+            while (i < j and nums[i] <= nums[left]) i += 1; // 从左向右找首个大于基准数的元素
+            swap(nums, i, j);   // 交换这两个元素
+        }
+        swap(nums, i, left);    // 将基准数交换至两子数组的分界线
+        return i;               // 返回基准数的索引
+    }
     ```
 
 !!! note "快速排序的分治思想"
@@ -420,7 +439,16 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
-
+    // 快速排序
+    fn quickSort(nums: []i32, left: usize, right: usize) void {
+        // 子数组长度为 1 时终止递归
+        if (left >= right) return;
+        // 哨兵划分
+        var pivot = partition(nums, left, right);
+        // 递归左子数组、右子数组
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
     ```
 
 ## 11.4.2. 算法特性
@@ -734,7 +762,36 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
+    // 选取三个元素的中位数
+    fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {
+        // 使用了异或操作来简化代码
+        // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if ((nums[left] < nums[mid]) != (nums[left] < nums[right])) {
+            return left;
+        } else if ((nums[mid] < nums[left]) != (nums[mid] < nums[right])) {
+            return mid;
+        } else {
+            return right;
+        }
+    }
 
+    // 哨兵划分（三数取中值）
+    fn partition(nums: []i32, left: usize, right: usize) usize {
+        // 选取三个候选元素的中位数
+        var med = medianThree(nums, left, (left + right) / 2, right);
+        // 将中位数交换至数组最左端
+        swap(nums, left, med);
+        // 以 nums[left] 作为基准数
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 从右向左找首个小于基准数的元素
+            while (i < j and nums[i] <= nums[left]) i += 1; // 从左向右找首个大于基准数的元素
+            swap(nums, i, j);   // 交换这两个元素
+        }
+        swap(nums, i, left);    // 将基准数交换至两子数组的分界线
+        return i;               // 返回基准数的索引
+    }
     ```
 
 ## 11.4.5. 尾递归优化
@@ -924,5 +981,22 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
-
+    // 快速排序（尾递归优化）
+    fn quickSort(nums: []i32, left_: usize, right_: usize) void {
+        var left = left_;
+        var right = right_;
+        // 子数组长度为 1 时终止递归
+        while (left < right) {
+            // 哨兵划分操作
+            var pivot = partition(nums, left, right);
+            // 对两个子数组中较短的那个执行快排
+            if (pivot - left < right - pivot) {
+                quickSort(nums, left, pivot - 1);   // 递归排序左子数组
+                left = pivot + 1;                   // 剩余待排序区间为 [pivot + 1, right]
+            } else {
+                quickSort(nums, pivot + 1, right);  // 递归排序右子数组
+                right = pivot - 1;                  // 剩余待排序区间为 [left, pivot - 1]
+            }
+        }
+    }
     ```