build

docs/chapter_sorting/bubble_sort.md

@@ -264,7 +264,7 @@ comments: true
             for (j in 0..<i) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
-                    nums[j] = nums[j+1].also { nums[j+1] = nums[j] }
+                    nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }
                 }
             }
         }

docs/chapter_sorting/bucket_sort.md

@@ -395,9 +395,9 @@ comments: true
     fun bucketSort(nums: FloatArray) {
         // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
         val k = nums.size / 2
-        val buckets = ArrayList<ArrayList<Float>>()
+        val buckets = mutableListOf<MutableList<Float>>()
         for (i in 0..<k) {
-            buckets.add(ArrayList())
+            buckets.add(mutableListOf())
         }
         // 1. 将数组元素分配到各个桶中
         for (num in nums) {

docs/chapter_sorting/counting_sort.md

@@ -324,7 +324,7 @@ comments: true
         // 1. 统计数组最大元素 m
         var m = 0
         for (num in nums) {
-            m = max(m.toDouble(), num.toDouble()).toInt()
+            m = max(m, num)
         }
         // 2. 统计各数字的出现次数
         // counter[num] 代表 num 的出现次数
@@ -822,7 +822,7 @@ $$
         // 1. 统计数组最大元素 m
         var m = 0
         for (num in nums) {
-            m = max(m.toDouble(), num.toDouble()).toInt()
+            m = max(m, num)
         }
         // 2. 统计各数字的出现次数
         // counter[num] 代表 num 的出现次数

docs/chapter_sorting/heap_sort.md

@@ -545,10 +545,13 @@ comments: true
             val l = 2 * i + 1
             val r = 2 * i + 2
             var ma = i
-            if (l < n && nums[l] > nums[ma]) ma = l
-            if (r < n && nums[r] > nums[ma]) ma = r
+            if (l < n && nums[l] > nums[ma]) 
+                ma = l
+            if (r < n && nums[r] > nums[ma]) 
+                ma = r
             // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
-            if (ma == i) break
+            if (ma == i) 
+                break
             // 交换两节点
             nums[i] = nums[ma].also { nums[ma] = nums[i] }
             // 循环向下堆化

docs/chapter_sorting/insertion_sort.md

@@ -240,7 +240,7 @@ comments: true
         for (i in nums.indices) {
             val base = nums[i]
             var j = i - 1
-            // 内循环: 将 base 插入到已排序部分的正确位置
+            // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
             while (j >= 0 && nums[j] > base) {
                 nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位
                 j--

docs/chapter_sorting/merge_sort.md

@@ -596,8 +596,10 @@ comments: true
         var k = 0
         // 当左右子数组都还有元素时，进行比较并将较小的元素复制到临时数组中
         while (i <= mid && j <= right) {
-            if (nums[i] <= nums[j]) tmp[k++] = nums[i++]
-            else tmp[k++] = nums[j++]
+            if (nums[i] <= nums[j])
+                tmp[k++] = nums[i++]
+            else 
+                tmp[k++] = nums[j++]
         }
         // 将左子数组和右子数组的剩余元素复制到临时数组中
         while (i <= mid) {

docs/chapter_sorting/radix_sort.md

@@ -636,7 +636,7 @@ $$
         // 统计 0~9 各数字的出现次数
         for (i in 0..<n) {
             val d = digit(nums[i], exp) // 获取 nums[i] 第 k 位，记为 d
-            counter[d]++ // 统计数字 d 的出现次数
+            counter[d]++                // 统计数字 d 的出现次数
         }
         // 求前缀和，将“出现个数”转换为“数组索引”
         for (i in 1..9) {
@@ -647,11 +647,12 @@ $$
         for (i in n - 1 downTo 0) {
             val d = digit(nums[i], exp)
             val j = counter[d] - 1 // 获取 d 在数组中的索引 j
-            res[j] = nums[i] // 将当前元素填入索引 j
-            counter[d]-- // 将 d 的数量减 1
+            res[j] = nums[i]       // 将当前元素填入索引 j
+            counter[d]--           // 将 d 的数量减 1
         }
         // 使用结果覆盖原数组 nums
-        for (i in 0..<n) nums[i] = res[i]
+        for (i in 0..<n)
+            nums[i] = res[i]
     }
 
     /* 基数排序 */

docs/chapter_sorting/selection_sort.md

@@ -292,7 +292,8 @@ comments: true
             var k = i
             // 内循环：找到未排序区间内的最小元素
             for (j in i + 1..<n) {
-                if (nums[j] < nums[k]) k = j // 记录最小元素的索引
+                if (nums[j] < nums[k])
+                    k = j // 记录最小元素的索引
             }
             // 将该最小元素与未排序区间的首个元素交换
             nums[i] = nums[k].also { nums[k] = nums[i] }