Update the book based on the revised second edition (#1014)

* Revised the book

* Update the book with the second revised edition

* Revise base on the manuscript of the first edition

codes/zig/chapter_array_and_linkedlist/my_list.zig

@@ -45,14 +45,14 @@ pub fn MyList(comptime T: type) type {
 
         // 访问元素
         pub fn get(self: *Self, index: usize) T {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 or index >= self.size()) @panic("索引越界");
             return self.arr[index];
         }  
 
         // 更新元素
         pub fn set(self: *Self, index: usize, num: T) void {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 or index >= self.size()) @panic("索引越界");
             self.arr[index] = num;
         }  
@@ -92,13 +92,13 @@ pub fn MyList(comptime T: type) type {
             }
             // 更新元素数量
             self.numSize -= 1;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
         // 列表扩容
         pub fn extendCapacity(self: *Self) !void {
-            // 新建一个长度为 size * extendRatio 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为 size * extendRatio 的数组，并将原数组复制到新数组
             var newCapacity = self.capacity() * self.extendRatio;
             var extend = try self.mem_allocator.alloc(T, newCapacity);
             @memset(extend, @as(T, 0));

codes/zig/chapter_hashing/array_hash_map.zig

@@ -128,7 +128,7 @@ pub fn main() !void {
     try map.print();
 
     // 查询操作
-    // 向哈希表输入键 key ，得到值 value
+    // 向哈希表中输入键 key ，得到值 value
     var name = map.get(15937);
     std.debug.print("\n输入学号 15937 ，查询到姓名 {s}\n", .{name});
 

codes/zig/chapter_hashing/hash_map.zig

@@ -23,7 +23,7 @@ pub fn main() !void {
     inc.PrintUtil.printHashMap(i32, []const u8, map);
 
     // 查询操作
-    // 向哈希表输入键 key ，得到值 value
+    // 向哈希表中输入键 key ，得到值 value
     var name = map.get(15937).?;
     std.debug.print("\n输入学号 15937 ，查询到姓名 {s}\n", .{name});
 

codes/zig/chapter_heap/my_heap.zig

@@ -30,17 +30,17 @@ pub fn MaxHeap(comptime T: type) type {
             if (self.max_heap != null) self.max_heap.?.deinit();
         }
 
-        // 获取左子节点索引
+        // 获取左子节点的索引
         fn left(i: usize) usize {
             return 2 * i + 1;
         }
 
-        // 获取右子节点索引
+        // 获取右子节点的索引
         fn right(i: usize) usize {
             return 2 * i + 2;
         }
 
-        // 获取父节点索引
+        // 获取父节点的索引
         fn parent(i: usize) usize {
             // return (i - 1) / 2; // 向下整除
             return @divFloor(i - 1, 2);

codes/zig/chapter_sorting/bubble_sort.zig

@@ -40,7 +40,7 @@ fn bubbleSortWithFlag(nums: []i32) void {
                 flag = true;
             }
         }
-        if (!flag) break;   // 此轮冒泡未交换任何元素，直接跳出
+        if (!flag) break;   // 此轮“冒泡”未交换任何元素，直接跳出
     }
 }
 

codes/zig/chapter_sorting/quick_sort.zig

@@ -51,7 +51,7 @@ const QuickSortMedian = struct {
         nums[j] = tmp;
     }
 
-    // 选取三个元素的中位数
+    // 选取三个候选元素的中位数
     pub fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {
         // 此处使用异或运算来简化代码
         // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1

codes/zig/chapter_stack_and_queue/array_queue.zig

@@ -55,10 +55,10 @@ pub fn ArrayQueue(comptime T: type) type {
                 std.debug.print("队列已满\n", .{});
                 return;
             }
-            // 计算尾指针，指向队尾索引 + 1
-            // 通过取余操作，实现 rear 越过数组尾部后回到头部
+            // 计算队尾指针，指向队尾索引 + 1
+            // 通过取余操作实现 rear 越过数组尾部后回到头部
             var rear = (self.front + self.queSize) % self.capacity();
-            // 尾节点后添加 num
+            // 在尾节点后添加 num
             self.nums[rear] = num;
             self.queSize += 1;
         } 
@@ -66,7 +66,7 @@ pub fn ArrayQueue(comptime T: type) type {
         // 出队
         pub fn pop(self: *Self) T {
             var num = self.peek();
-            // 队首指针向后移动一位，若越过尾部则返回到数组头部
+            // 队首指针向后移动一位，若越过尾部，则返回到数组头部
             self.front = (self.front + 1) % self.capacity();
             self.queSize -= 1;
             return num;

codes/zig/chapter_stack_and_queue/linkedlist_queue.zig

@@ -51,7 +51,7 @@ pub fn LinkedListQueue(comptime T: type) type {
 
         // 入队
         pub fn push(self: *Self, num: T) !void {
-            // 尾节点后添加 num
+            // 在尾节点后添加 num
             var node = try self.mem_allocator.create(inc.ListNode(T));
             node.init(num);
             // 如果队列为空，则令头、尾节点都指向该节点

codes/zig/chapter_tree/avl_tree.zig

@@ -120,7 +120,7 @@ pub fn AVLTree(comptime T: type) type {
                 tmp_node.init(val);
                 return tmp_node;
             }
-            // 1. 查找插入位置，并插入节点
+            // 1. 查找插入位置并插入节点
             if (val < node.?.val) {
                 node.?.left = try self.insertHelper(node.?.left, val);
             } else if (val > node.?.val) {
@@ -144,7 +144,7 @@ pub fn AVLTree(comptime T: type) type {
         fn removeHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) ?*inc.TreeNode(T) {
             var node = node_;
             if (node == null) return null;
-            // 1. 查找节点，并删除之
+            // 1. 查找节点并删除
             if (val < node.?.val) {
                 node.?.left = self.removeHelper(node.?.left, val);
             } else if (val > node.?.val) {