build

docs/chapter_sorting/bucket_sort.md

@@ -406,7 +406,35 @@ comments: true
 === "Ruby"
 
     ```ruby title="bucket_sort.rb"
-    [class]{}-[func]{bucket_sort}
+    ### 桶排序 ###
+    def bucket_sort(nums)
+      # 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+      k = nums.length / 2
+      buckets = Array.new(k) { [] }
+      
+      # 1. 将数组元素分配到各个桶中
+      nums.each do |num|
+        # 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        i = (num * k).to_i
+        # 将 num 添加进桶 i
+        buckets[i] << num
+      end
+
+      # 2. 对各个桶执行排序
+      buckets.each do |bucket|
+        # 使用内置排序函数，也可以替换成其他排序算法
+        bucket.sort!
+      end
+
+      # 3. 遍历桶合并结果
+      i = 0
+      buckets.each do |bucket|
+        bucket.each do |num|
+          nums[i] = num
+          i += 1
+        end
+      end
+    end
     ```
 
 === "Zig"

docs/chapter_sorting/heap_sort.md

@@ -582,9 +582,38 @@ comments: true
 === "Ruby"
 
     ```ruby title="heap_sort.rb"
-    [class]{}-[func]{sift_down}
+    ### 堆的长度为 n ，从节点 i 开始，从顶至底堆化 ###
+    def sift_down(nums, n, i)
+      while true
+        # 判断节点 i, l, r 中值最大的节点，记为 ma
+        l = 2 * i + 1
+        r = 2 * i + 2
+        ma = i
+        ma = l if l < n && nums[l] > nums[ma]
+        ma = r if r < n && nums[r] > nums[ma]
+        # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        break if ma == i
+        # 交换两节点
+        nums[i], nums[ma] = nums[ma], nums[i]
+        # 循环向下堆化
+        i = ma
+      end
+    end
 
-    [class]{}-[func]{heap_sort}
+    ### 堆排序 ###
+    def heap_sort(nums)
+      # 建堆操作：堆化除叶节点以外的其他所有节点
+      (nums.length / 2 - 1).downto(0) do |i|
+        sift_down(nums, nums.length, i)
+      end
+      # 从堆中提取最大元素，循环 n-1 轮
+      (nums.length - 1).downto(1) do |i|
+        # 交换根节点与最右叶节点（交换首元素与尾元素）
+        nums[0], nums[i] = nums[i], nums[0]
+        # 以根节点为起点，从顶至底进行堆化
+        sift_down(nums, i, 0)
+      end
+    end
     ```
 
 === "Zig"

docs/chapter_sorting/merge_sort.md

@@ -630,9 +630,53 @@ comments: true
 === "Ruby"
 
     ```ruby title="merge_sort.rb"
-    [class]{}-[func]{merge}
+    ### 合并左子数组和右子数组 ###
+    def merge(nums, left, mid, right)
+      # 左子数组区间为 [left, mid], 右子数组区间为 [mid+1, right]
+      # 创建一个临时数组 tmp，用于存放合并后的结果
+      tmp = Array.new(right - left + 1, 0)
+      # 初始化左子数组和右子数组的起始索引
+      i, j, k = left, mid + 1, 0
+      # 当左右子数组都还有元素时，进行比较并将较小的元素复制到临时数组中
+      while i <= mid && j <= right
+        if nums[i] <= nums[j]
+          tmp[k] = nums[i]
+          i += 1
+        else
+          tmp[k] = nums[j]
+          j += 1
+        end
+        k += 1
+      end
+      # 将左子数组和右子数组的剩余元素复制到临时数组中
+      while i <= mid
+        tmp[k] = nums[i]
+        i += 1
+        k += 1
+      end
+      while j <= right
+        tmp[k] = nums[j]
+        j += 1
+        k += 1
+      end
+      # 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间
+      (0...tmp.length).each do |k|
+        nums[left + k] = tmp[k]
+      end
+    end
 
-    [class]{}-[func]{merge_sort}
+    ### 归并排序 ###
+    def merge_sort(nums, left, right)
+      # 终止条件
+      # 当子数组长度为 1 时终止递归
+      return if left >= right
+      # 划分阶段
+      mid = (left + right) / 2 # 计算中点
+      merge_sort(nums, left, mid) # 递归左子数组
+      merge_sort(nums, mid + 1, right) # 递归右子数组
+      # 合并阶段
+      merge(nums, left, mid, right)
+    end
     ```
 
 === "Zig"