Add the section of radix sort. (#441)

codes/zig/chapter_sorting/radix_sort.zig

@@ -12,57 +12,56 @@ fn digit(num: i32, exp: i32) i32 {
 }
 
 // 计数排序（根据 nums 第 k 位排序）
-fn countingSort(nums: []i32, exp: i32) !void {
-    // 十进制的各位数字范围为 0~9 ，因此需要长度为 10 的桶
+fn countingSortDigit(nums: []i32, exp: i32) !void {
+    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
     var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     // defer mem_arena.deinit();
     const mem_allocator = mem_arena.allocator();
-    var bucket = try mem_allocator.alloc(usize, 10);
-    std.mem.set(usize, bucket, 0);
+    var counter = try mem_allocator.alloc(usize, 10);
+    std.mem.set(usize, counter, 0);
     var n = nums.len;
-    // 借助桶来统计 0~9 各数字的出现次数
+    // 统计 0~9 各数字的出现次数
     for (nums) |num| {
-        var d = @bitCast(u32, digit(num, exp));    // 获取 nums[i] 第 k 位，记为 d
-        bucket[d] += 1;             // 统计数字 d 的出现次数
+        var d = @bitCast(u32, digit(num, exp)); // 获取 nums[i] 第 k 位，记为 d
+        counter[d] += 1; // 统计数字 d 的出现次数
     }
     // 求前缀和，将“出现个数”转换为“数组索引”
     var i: usize = 1;
     while (i < 10) : (i += 1) {
-        bucket[i] += bucket[i - 1];
+        counter[i] += counter[i - 1];
     }
-    // 倒序遍历，根据桶内统计结果，将各元素填入暂存数组 tmp
-    var tmp = try mem_allocator.alloc(i32, n);
+    // 倒序遍历，根据桶内统计结果，将各元素填入 res
+    var res = try mem_allocator.alloc(i32, n);
     i = n - 1;
     while (i >= 0) : (i -= 1) {
         var d = @bitCast(u32, digit(nums[i], exp));
-        var j = bucket[d] - 1;  // 获取 d 在数组中的索引 j
-        tmp[j] = nums[i];       // 将当前元素填入索引 j
-        bucket[d] -= 1;         // 将 d 的数量减 1
+        var j = counter[d] - 1; // 获取 d 在数组中的索引 j
+        res[j] = nums[i];       // 将当前元素填入索引 j
+        counter[d] -= 1;        // 将 d 的数量减 1
         if (i == 0) break;
     }
-    // 将 tmp 复制到 nums
+    // 使用结果覆盖原数组 nums
     i = 0;
     while (i < n) : (i += 1) {
-        nums[i] = tmp[i];
+        nums[i] = res[i];
     }
 }
 
 // 基数排序
 fn radixSort(nums: []i32) !void {
     // 获取数组的最大元素，用于判断最大位数
-    var ma: i32 = std.math.minInt(i32);
+    var m: i32 = std.math.minInt(i32);
     for (nums) |num| {
-        if (num > ma) ma = num;
+        if (num > m) m = num;
     }
     // 按照从低位到高位的顺序遍历
     var exp: i32 = 1;
-    while (ma >= exp) : (exp *= 10) {
-        // 对数组元素的第 k 位执行「计数排序」
+    while (exp <= m) : (exp *= 10) {
+        // 对数组元素的第 k 位执行计数排序
         // k = 1 -> exp = 1
         // k = 2 -> exp = 10
-        // k = 3 -> exp = 100
         // 即 exp = 10^(k-1)
-        try countingSort(nums, exp);    
+        try countingSortDigit(nums, exp);    
     }
 }