build

docs/chapter_sorting/bubble_sort.md

@@ -225,9 +225,7 @@ comments: true
             for j in 0..i {
                 if nums[j] > nums[j + 1] {
                     // 交换 nums[j] 与 nums[j + 1]
-                    let tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    nums.swap(j, j + 1);
                 }
             }
         }
@@ -538,9 +536,7 @@ comments: true
             for j in 0..i {
                 if nums[j] > nums[j + 1] {
                     // 交换 nums[j] 与 nums[j + 1]
-                    let tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    nums.swap(j, j + 1);
                     flag = true; // 记录交换元素
                 }
             }

docs/chapter_sorting/bucket_sort.md

@@ -314,7 +314,7 @@ comments: true
         let k = nums.len() / 2;
         let mut buckets = vec![vec![]; k];
         // 1. 将数组元素分配到各个桶中
-        for &mut num in &mut *nums {
+        for &num in nums.iter() {
             // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
             let i = (num * k as f64) as usize;
             // 将 num 添加进桶 i
@@ -327,8 +327,8 @@ comments: true
         }
         // 3. 遍历桶合并结果
         let mut i = 0;
-        for bucket in &mut buckets {
-            for &mut num in bucket {
+        for bucket in buckets.iter() {
+            for &num in bucket.iter() {
                 nums[i] = num;
                 i += 1;
             }

docs/chapter_sorting/counting_sort.md

@@ -266,11 +266,11 @@ comments: true
     // 简单实现，无法用于排序对象
     fn counting_sort_naive(nums: &mut [i32]) {
         // 1. 统计数组最大元素 m
-        let m = *nums.into_iter().max().unwrap();
+        let m = *nums.iter().max().unwrap();
         // 2. 统计各数字的出现次数
         // counter[num] 代表 num 的出现次数
         let mut counter = vec![0; m as usize + 1];
-        for &num in &*nums {
+        for &num in nums.iter() {
             counter[num as usize] += 1;
         }
         // 3. 遍历 counter ，将各元素填入原数组 nums
@@ -764,16 +764,16 @@ $$
     // 完整实现，可排序对象，并且是稳定排序
     fn counting_sort(nums: &mut [i32]) {
         // 1. 统计数组最大元素 m
-        let m = *nums.into_iter().max().unwrap();
+        let m = *nums.iter().max().unwrap() as usize;
         // 2. 统计各数字的出现次数
         // counter[num] 代表 num 的出现次数
-        let mut counter = vec![0; m as usize + 1];
-        for &num in &*nums {
+        let mut counter = vec![0; m + 1];
+        for &num in nums.iter() {
             counter[num as usize] += 1;
         }
         // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
         // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
-        for i in 0..m as usize {
+        for i in 0..m {
             counter[i + 1] += counter[i];
         }
         // 4. 倒序遍历 nums ，将各元素填入结果数组 res
@@ -786,9 +786,7 @@ $$
             counter[num as usize] -= 1; // 令前缀和自减 1 ，得到下次放置 num 的索引
         }
         // 使用结果数组 res 覆盖原数组 nums
-        for i in 0..n {
-            nums[i] = res[i];
-        }
+        nums.copy_from_slice(&res)
     }
     ```
 

docs/chapter_sorting/heap_sort.md

@@ -463,9 +463,7 @@ comments: true
                 break;
             }
             // 交换两节点
-            let temp = nums[i];
-            nums[i] = nums[ma];
-            nums[ma] = temp;
+            nums.swap(i, ma);
             // 循环向下堆化
             i = ma;
         }
@@ -474,15 +472,13 @@ comments: true
     /* 堆排序 */
     fn heap_sort(nums: &mut [i32]) {
         // 建堆操作：堆化除叶节点以外的其他所有节点
-        for i in (0..=nums.len() / 2 - 1).rev() {
+        for i in (0..nums.len() / 2).rev() {
             sift_down(nums, nums.len(), i);
         }
         // 从堆中提取最大元素，循环 n-1 轮
-        for i in (1..=nums.len() - 1).rev() {
+        for i in (1..nums.len()).rev() {
             // 交换根节点与最右叶节点（交换首元素与尾元素）
-            let tmp = nums[0];
-            nums[0] = nums[i];
-            nums[i] = tmp;
+            nums.swap(0, i);
             // 以根节点为起点，从顶至底进行堆化
             sift_down(nums, i, 0);
         }