diff --git a/chapter_array_and_linkedlist/array.md b/chapter_array_and_linkedlist/array.md
index 354d64717..c8cb05a89 100755
--- a/chapter_array_and_linkedlist/array.md
+++ b/chapter_array_and_linkedlist/array.md
@@ -230,7 +230,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```zig title="array.zig"
     // 随机返回一个数组元素
-    pub fn randomAccess(nums: []i32) i32 {
+    fn randomAccess(nums: []i32) i32 {
         // 在区间 [0, nums.len) 中随机抽取一个整数
         var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
         // 获取并返回随机元素
@@ -389,7 +389,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```zig title="array.zig"
     // 扩展数组长度
-    pub fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
+    fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
         // 初始化一个扩展长度后的数组
         var res = try mem_allocator.alloc(i32, nums.len + enlarge);
         std.mem.set(i32, res, 0);
@@ -597,7 +597,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```zig title="array.zig"
     // 在数组的索引 index 处插入元素 num
-    pub fn insert(nums: []i32, num: i32, index: usize) void {
+    fn insert(nums: []i32, num: i32, index: usize) void {
         // 把索引 index 以及之后的所有元素向后移动一位
         var i = nums.len - 1;
         while (i > index) : (i -= 1) {
@@ -608,7 +608,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
 
     // 删除索引 index 处元素
-    pub fn remove(nums: []i32, index: usize) void {
+    fn remove(nums: []i32, index: usize) void {
         // 把索引 index 之后的所有元素向前移动一位
         var i = index;
         while (i < nums.len - 1) : (i += 1) {
@@ -764,7 +764,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```zig title="array.zig"
     // 遍历数组
-    pub fn traverse(nums: []i32) void {
+    fn traverse(nums: []i32) void {
         var count: i32 = 0;
         // 通过索引遍历数组
         var i: i32 = 0;
@@ -899,7 +899,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```zig title="array.zig"
     // 在数组中查找指定元素
-    pub fn find(nums: []i32, target: i32) i32 {
+    fn find(nums: []i32, target: i32) i32 {
         for (nums) |num, i| {
             if (num == target) return @intCast(i32, i);
         }
diff --git a/chapter_array_and_linkedlist/linked_list.md b/chapter_array_and_linkedlist/linked_list.md
index 5d6dbff9a..ca3d6110b 100755
--- a/chapter_array_and_linkedlist/linked_list.md
+++ b/chapter_array_and_linkedlist/linked_list.md
@@ -506,14 +506,14 @@ comments: true
 
     ```zig title="linked_list.zig"
     // 在链表的结点 n0 之后插入结点 P
-    pub fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
+    fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
         var n1 = n0.?.next;
         n0.?.next = P;
         P.?.next = n1;
     }
 
     // 删除链表的结点 n0 之后的首个结点
-    pub fn remove(n0: ?*inc.ListNode(i32)) void {
+    fn remove(n0: ?*inc.ListNode(i32)) void {
         if (n0.?.next == null) return;
         // n0 -> P -> n1
         var P = n0.?.next;
@@ -653,7 +653,7 @@ comments: true
 
     ```zig title="linked_list.zig"
     // 访问链表中索引为 index 的结点
-    pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
+    fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
         var head = node;
         var i: i32 = 0;
         while (i < index) : (i += 1) {
@@ -813,7 +813,7 @@ comments: true
 
     ```zig title="linked_list.zig"
     // 在链表中查找值为 target 的首个结点
-    pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
+    fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
         var head = node;
         var index: i32 = 0;
         while (head != null) {
diff --git a/chapter_array_and_linkedlist/list.md b/chapter_array_and_linkedlist/list.md
index a2c4a4a84..37dc6d7d5 100755
--- a/chapter_array_and_linkedlist/list.md
+++ b/chapter_array_and_linkedlist/list.md
@@ -1552,7 +1552,7 @@ comments: true
 
     ```zig title="my_list.zig"
     // 列表类简易实现
-    pub fn MyList(comptime T: type) type {
+    fn MyList(comptime T: type) type {
         return struct {
             const Self = @This();
             
diff --git a/chapter_computational_complexity/space_time_tradeoff.md b/chapter_computational_complexity/space_time_tradeoff.md
index b88d53c30..abdf5a166 100755
--- a/chapter_computational_complexity/space_time_tradeoff.md
+++ b/chapter_computational_complexity/space_time_tradeoff.md
@@ -177,23 +177,22 @@ comments: true
 === "Zig"
 
     ```zig title="leetcode_two_sum.zig"
-    const SolutionBruteForce = struct {
-        pub fn twoSum(self: *SolutionBruteForce, nums: []i32, target: i32) [2]i32 {
-            _ = self;
-            var size: usize = nums.len;
-            var i: usize = 0;
-            // 两层循环，时间复杂度 O(n^2)
-            while (i < size - 1) : (i += 1) {
-                var j = i + 1;
-                while (j < size) : (j += 1) {
-                    if (nums[i] + nums[j] == target) {
-                        return [_]i32{@intCast(i32, i), @intCast(i32, j)};
-                    }
+    // 方法一：暴力枚举
+    fn twoSumBruteForce(nums: []i32, target: i32) [2]i32 {
+        _ = self;
+        var size: usize = nums.len;
+        var i: usize = 0;
+        // 两层循环，时间复杂度 O(n^2)
+        while (i < size - 1) : (i += 1) {
+            var j = i + 1;
+            while (j < size) : (j += 1) {
+                if (nums[i] + nums[j] == target) {
+                    return [_]i32{@intCast(i32, i), @intCast(i32, j)};
                 }
             }
-            return undefined;
         }
-    };
+        return undefined;
+    }
     ```
 
 ### 方法二：辅助哈希表
@@ -361,22 +360,21 @@ comments: true
 === "Zig"
 
     ```zig title="leetcode_two_sum.zig"
-    const SolutionHashMap = struct {
-        pub fn twoSum(self: *SolutionHashMap, nums: []i32, target: i32) ![2]i32 {
-            _ = self;
-            var size: usize = nums.len;
-            // 辅助哈希表，空间复杂度 O(n)
-            var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
-            defer dic.deinit();
-            var i: usize = 0;
-            // 单层循环，时间复杂度 O(n)
-            while (i < size) : (i += 1) {
-                if (dic.contains(target - nums[i])) {
-                    return [_]i32{dic.get(target - nums[i]).?, @intCast(i32, i)};
-                }
-                try dic.put(nums[i], @intCast(i32, i));
+    // 方法二：辅助哈希表
+    fn twoSumHashTable(nums: []i32, target: i32) ![2]i32 {
+        _ = self;
+        var size: usize = nums.len;
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
+        defer dic.deinit();
+        var i: usize = 0;
+        // 单层循环，时间复杂度 O(n)
+        while (i < size) : (i += 1) {
+            if (dic.contains(target - nums[i])) {
+                return [_]i32{dic.get(target - nums[i]).?, @intCast(i32, i)};
             }
-            return undefined;
+            try dic.put(nums[i], @intCast(i32, i));
         }
-    };
+        return undefined;
+    }
     ```
diff --git a/chapter_computational_complexity/time_complexity.md b/chapter_computational_complexity/time_complexity.md
index 1e9bfaa21..44ad40fbd 100755
--- a/chapter_computational_complexity/time_complexity.md
+++ b/chapter_computational_complexity/time_complexity.md
@@ -1363,7 +1363,7 @@ $$
             }
         }
         return count;
-    }   
+    }
     ```
 
 ![time_complexity_constant_linear_quadratic](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
@@ -1788,7 +1788,7 @@ $$
 
     ```zig title="time_complexity.zig"
     // 指数阶（循环实现）
-    fn exponential(n: i32) i32{
+    fn exponential(n: i32) i32 {
         var count: i32 = 0;
         var bas: i32 = 1;
         var i: i32 = 0;
@@ -1802,7 +1802,7 @@ $$
         }
         // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
         return count;
-    }       
+    }
     ```
 
 ![time_complexity_exponential](time_complexity.assets/time_complexity_exponential.png)
@@ -1909,7 +1909,7 @@ $$
 
     ```zig title="time_complexity.zig"
     // 指数阶（递归实现）
-    fn expRecur(n: i32) i32{
+    fn expRecur(n: i32) i32 {
         if (n == 1) return 1;
         return expRecur(n - 1) + expRecur(n - 1) + 1;
     }
@@ -2054,8 +2054,7 @@ $$
 
     ```zig title="time_complexity.zig"
     // 对数阶（循环实现）
-    fn logarithmic(n: f32) i32
-    {
+    fn logarithmic(n: f32) i32 {
         var count: i32 = 0;
         var n_var = n;
         while (n_var > 1)
@@ -2171,8 +2170,7 @@ $$
 
     ```zig title="time_complexity.zig"
     // 对数阶（递归实现）
-    fn logRecur(n: f32) i32
-    {
+    fn logRecur(n: f32) i32 {
         if (n <= 1) return 0;
         return logRecur(n / 2) + 1;
     }
@@ -2324,8 +2322,7 @@ $$
 
     ```zig title="time_complexity.zig"
     // 线性对数阶
-    fn linearLogRecur(n: f32) i32
-    {
+    fn linearLogRecur(n: f32) i32 {
         if (n <= 1) return 1;
         var count: i32 = linearLogRecur(n / 2) +
                     linearLogRecur(n / 2);
diff --git a/chapter_hashing/hash_map.md b/chapter_hashing/hash_map.md
index 7d49dd6bc..00469674a 100755
--- a/chapter_hashing/hash_map.md
+++ b/chapter_hashing/hash_map.md
@@ -1158,7 +1158,110 @@ $$
 === "Zig"
 
     ```zig title="array_hash_map.zig"
+    // 键值对 int->String
+    const Entry = struct {
+        key: usize = undefined,
+        val: []const u8 = undefined,
 
+        pub fn init(key: usize, val: []const u8) Entry {
+            return Entry {
+                .key = key,
+                .val = val,
+            };
+        }
+    };
+
+    // 基于数组简易实现的哈希表
+    fn ArrayHashMap(comptime T: type) type {
+        return struct {
+            bucket: ?std.ArrayList(?T) = null,
+            mem_allocator: std.mem.Allocator = undefined,
+
+            const Self = @This();
+            
+            // 构造函数
+            pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
+                self.mem_allocator = allocator;
+                // 初始化一个长度为 100 的桶（数组）
+                self.bucket = std.ArrayList(?T).init(self.mem_allocator);
+                var i: i32 = 0;
+                while (i < 100) : (i += 1) {
+                    try self.bucket.?.append(null);
+                }
+            }
+
+            // 析构函数
+            pub fn deinit(self: *Self) void {
+                if (self.bucket != null) self.bucket.?.deinit();
+            }
+
+            // 哈希函数
+            fn hashFunc(key: usize) usize {
+                var index = key % 100;
+                return index;
+            }
+
+            // 查询操作
+            pub fn get(self: *Self, key: usize) []const u8 {
+                var index = hashFunc(key);
+                var pair = self.bucket.?.items[index];
+                return pair.?.val;
+            }
+
+            // 添加操作
+            pub fn put(self: *Self, key: usize, val: []const u8) !void {
+                var pair = Entry.init(key, val);
+                var index = hashFunc(key);
+                self.bucket.?.items[index] = pair;
+            }
+
+            // 删除操作
+            pub fn remove(self: *Self, key: usize) !void {
+                var index = hashFunc(key);
+                // 置为 null ，代表删除
+                self.bucket.?.items[index] = null;
+            }       
+
+            // 获取所有键值对
+            pub fn entrySet(self: *Self) !*std.ArrayList(T) {
+                var entry_set = std.ArrayList(T).init(self.mem_allocator);
+                for (self.bucket.?.items) |item| {
+                    if (item == null) continue;
+                    try entry_set.append(item.?);
+                }
+                return &entry_set;
+            }  
+
+            // 获取所有键
+            pub fn keySet(self: *Self) !*std.ArrayList(usize) {
+                var key_set = std.ArrayList(usize).init(self.mem_allocator);
+                for (self.bucket.?.items) |item| {
+                    if (item == null) continue;
+                    try key_set.append(item.?.key);
+                }
+                return &key_set;
+            }  
+
+            // 获取所有值
+            pub fn valueSet(self: *Self) !*std.ArrayList([]const u8) {
+                var value_set = std.ArrayList([]const u8).init(self.mem_allocator);
+                for (self.bucket.?.items) |item| {
+                    if (item == null) continue;
+                    try value_set.append(item.?.val);
+                }
+                return &value_set;
+            }
+
+            // 打印哈希表
+            pub fn print(self: *Self) !void {
+                var entry_set = try self.entrySet();
+                defer entry_set.deinit();
+                for (entry_set.items) |item| {
+                    std.debug.print("{} -> {s}\n", .{item.key, item.val});
+                }
+            }
+        };
+    }
     ```
 
 ## 6.1.4. 哈希冲突
diff --git a/chapter_heap/heap.md b/chapter_heap/heap.md
index 2703adc0e..4e309bf18 100644
--- a/chapter_heap/heap.md
+++ b/chapter_heap/heap.md
@@ -397,7 +397,21 @@ comments: true
 === "Zig"
 
     ```zig title="my_heap.zig"
+    // 获取左子结点索引
+    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);
+    }
     ```
 
 ### 访问堆顶元素
@@ -479,7 +493,10 @@ comments: true
 === "Zig"
 
     ```zig title="my_heap.zig"
-
+    // 访问堆顶元素
+    fn peek(self: *Self) T {
+        return self.maxHeap.?.items[0];
+    }  
     ```
 
 ### 元素入堆
@@ -694,7 +711,28 @@ comments: true
 === "Zig"
 
     ```zig title="my_heap.zig"
+    // 元素入堆
+    fn push(self: *Self, val: T) !void {
+        // 添加结点
+        try self.maxHeap.?.append(val);
+        // 从底至顶堆化
+        try self.siftUp(self.size() - 1);
+    }  
 
+    // 从结点 i 开始，从底至顶堆化
+    fn siftUp(self: *Self, i_: usize) !void {
+        var i = i_;
+        while (true) {
+            // 获取结点 i 的父结点
+            var p = parent(i);
+            // 当“越过根结点”或“结点无需修复”时，结束堆化
+            if (p < 0 or self.maxHeap.?.items[i] <= self.maxHeap.?.items[p]) break;
+            // 交换两结点
+            try self.swap(i, p);
+            // 循环向上堆化
+            i = p;
+        }
+    }
     ```
 
 ### 堆顶元素出堆
@@ -998,7 +1036,38 @@ comments: true
 === "Zig"
 
     ```zig title="my_heap.zig"
+    // 元素出堆
+    fn poll(self: *Self) !T {
+        // 判断处理
+        if (self.isEmpty()) unreachable;
+        // 交换根结点与最右叶结点（即交换首元素与尾元素）
+        try self.swap(0, self.size() - 1);
+        // 删除结点
+        var val = self.maxHeap.?.pop();
+        // 从顶至底堆化
+        try self.siftDown(0);
+        // 返回堆顶元素
+        return val;
+    } 
 
+    // 从结点 i 开始，从顶至底堆化
+    fn siftDown(self: *Self, i_: usize) !void {
+        var i = i_;
+        while (true) {
+            // 判断结点 i, l, r 中值最大的结点，记为 ma
+            var l = left(i);
+            var r = right(i);
+            var ma = i;
+            if (l < self.size() and self.maxHeap.?.items[l] > self.maxHeap.?.items[ma]) ma = l;
+            if (r < self.size() and self.maxHeap.?.items[r] > self.maxHeap.?.items[ma]) ma = r;
+            // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            if (ma == i) break;
+            // 交换两结点
+            try self.swap(i, ma);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
     ```
 
 ### 输入数据并建堆 *
@@ -1113,7 +1182,18 @@ comments: true
 === "Zig"
 
     ```zig title="my_heap.zig"
-
+    // 构造函数，根据输入列表建堆
+    fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
+        if (self.maxHeap != null) return;
+        self.maxHeap = std.ArrayList(T).init(allocator);
+        // 将列表元素原封不动添加进堆
+        try self.maxHeap.?.appendSlice(nums);
+        // 堆化除叶结点以外的其他所有结点
+        var i: usize = parent(self.size() - 1) + 1;
+        while (i > 0) : (i -= 1) {
+            try self.siftDown(i - 1);
+        }
+    }
     ```
 
 那么，第二种建堆方法的时间复杂度时多少呢？我们来做一下简单推算。
diff --git a/chapter_searching/binary_search.md b/chapter_searching/binary_search.md
index a2677d520..36bcabfaa 100755
--- a/chapter_searching/binary_search.md
+++ b/chapter_searching/binary_search.md
@@ -237,7 +237,25 @@ $$
 === "Zig"
 
     ```zig title="binary_search.zig"
-
+    // 二分查找（双闭区间）
+    fn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        var i: usize = 0;
+        var j: usize = nums.items.len - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            var m = (i + j) / 2;                    // 计算中点索引 m
+            if (nums.items[m] < target) {           // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                                // 找到目标元素，返回其索引
+                return @intCast(T, m);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 ### “左闭右开”实现
@@ -431,7 +449,25 @@ $$
 === "Zig"
 
     ```zig title="binary_search.zig"
-
+    // 二分查找（左闭右开）
+    fn binarySearch1(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        var i: usize = 0;
+        var j: usize = nums.items.len;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i <= j) {
+            var m = (i + j) / 2;                    // 计算中点索引 m
+            if (nums.items[m] < target) {           // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {                                // 找到目标元素，返回其索引
+                return @intCast(T, m);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 ### 两种表示对比
diff --git a/chapter_searching/hashing_search.md b/chapter_searching/hashing_search.md
index 7187ee2ae..0cc61b3a4 100755
--- a/chapter_searching/hashing_search.md
+++ b/chapter_searching/hashing_search.md
@@ -119,7 +119,13 @@ comments: true
 === "Zig"
 
     ```zig title="hashing_search.zig"
-
+    // 哈希查找（数组）
+    fn hashingSearchArray(comptime T: type, map: std.AutoHashMap(T, T), target: T) T {
+        // 哈希表的 key: 目标元素，value: 索引
+        // 若哈希表中无此 key ，返回 -1   
+        if (map.getKey(target) == null) return -1;
+        return map.get(target).?;
+    }
     ```
 
 再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
@@ -230,7 +236,13 @@ comments: true
 === "Zig"
 
     ```zig title="hashing_search.zig"
-
+    // 哈希查找（链表）
+    fn hashingSearchLinkedList(comptime T: type, map: std.AutoHashMap(T, *inc.ListNode(T)), target: T) ?*inc.ListNode(T) {
+        // 哈希表的 key: 目标结点值，value: 结点对象
+        // 若哈希表中无此 key ，返回 null 
+        if (map.getKey(target) == null) return null;
+        return map.get(target);
+    }
     ```
 
 ## 10.3.2. 复杂度分析
diff --git a/chapter_searching/linear_search.md b/chapter_searching/linear_search.md
index 0efe70c17..2b653a040 100755
--- a/chapter_searching/linear_search.md
+++ b/chapter_searching/linear_search.md
@@ -151,7 +151,18 @@ comments: true
 === "Zig"
 
     ```zig title="linear_search.zig"
-
+    // 线性查找（数组）
+    fn linearSearchArray(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 遍历数组
+        for (nums.items) |num, i| {
+            // 找到目标元素， 返回其索引
+            if (num == target) {
+                return @intCast(T, i);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
@@ -304,7 +315,17 @@ comments: true
 === "Zig"
 
     ```zig title="linear_search.zig"
-
+    // 线性查找（链表）
+    fn linearSearchLinkedList(comptime T: type, node: ?*inc.ListNode(T), target: T) ?*inc.ListNode(T) {
+        var head = node;
+        // 遍历链表
+        while (head != null) {
+            // 找到目标结点，返回之
+            if (head.?.val == target) return head;
+            head = head.?.next;
+        }
+        return null;
+    }
     ```
 
 ## 10.1.2. 复杂度分析
diff --git a/chapter_sorting/bubble_sort.md b/chapter_sorting/bubble_sort.md
index 8b2ee71c2..ff2f2ce5f 100755
--- a/chapter_sorting/bubble_sort.md
+++ b/chapter_sorting/bubble_sort.md
@@ -228,7 +228,23 @@ comments: true
 === "Zig"
 
     ```zig title="bubble_sort.zig"
-
+    // 冒泡排序
+    fn bubbleSort(nums: []i32) void {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var j: usize = 0;
+            // 内循环：冒泡操作
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 ## 11.2.2. 算法特性
@@ -461,5 +477,24 @@ comments: true
 === "Zig"
 
     ```zig title="bubble_sort.zig"
-
+    // 冒泡排序（标志优化）
+    fn bubbleSortWithFlag(nums: []i32) void {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var flag = false;   // 初始化标志位
+            var j: usize = 0;
+            // 内循环：冒泡操作
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;
+                }
+            }
+            if (!flag) break;   // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
diff --git a/chapter_sorting/insertion_sort.md b/chapter_sorting/insertion_sort.md
index db96e330a..1eacaca60 100755
--- a/chapter_sorting/insertion_sort.md
+++ b/chapter_sorting/insertion_sort.md
@@ -197,7 +197,20 @@ comments: true
 === "Zig"
 
     ```zig title="insertion_sort.zig"
-
+    // 插入排序
+    fn insertionSort(nums: []i32) void {
+        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        var i: usize = 1;
+        while (i < nums.len) : (i += 1) {
+            var base = nums[i];
+            var j: usize = i;
+            // 内循环：将 base 插入到左边的正确位置
+            while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
+                nums[j] = nums[j - 1];  // 1. 将 nums[j] 向右移动一位
+            }
+            nums[j] = base;             // 2. 将 base 赋值到正确位置
+        }
+    }
     ```
 
 ## 11.3.2. 算法特性
diff --git a/chapter_sorting/quick_sort.md b/chapter_sorting/quick_sort.md
index 7308bd5d1..376d12dfb 100755
--- a/chapter_sorting/quick_sort.md
+++ b/chapter_sorting/quick_sort.md
@@ -262,7 +262,26 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
+    // 元素交换
+    fn swap(nums: []i32, i: usize, j: usize) void {
+        var tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
 
+    // 哨兵划分
+    fn partition(nums: []i32, left: usize, right: usize) usize {
+        // 以 nums[left] 作为基准数
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 从右向左找首个小于基准数的元素
+            while (i < j and nums[i] <= nums[left]) i += 1; // 从左向右找首个大于基准数的元素
+            swap(nums, i, j);   // 交换这两个元素
+        }
+        swap(nums, i, left);    // 将基准数交换至两子数组的分界线
+        return i;               // 返回基准数的索引
+    }
     ```
 
 !!! note "快速排序的分治思想"
@@ -420,7 +439,16 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
-
+    // 快速排序
+    fn quickSort(nums: []i32, left: usize, right: usize) void {
+        // 子数组长度为 1 时终止递归
+        if (left >= right) return;
+        // 哨兵划分
+        var pivot = partition(nums, left, right);
+        // 递归左子数组、右子数组
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
     ```
 
 ## 11.4.2. 算法特性
@@ -734,7 +762,36 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
+    // 选取三个元素的中位数
+    fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {
+        // 使用了异或操作来简化代码
+        // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if ((nums[left] < nums[mid]) != (nums[left] < nums[right])) {
+            return left;
+        } else if ((nums[mid] < nums[left]) != (nums[mid] < nums[right])) {
+            return mid;
+        } else {
+            return right;
+        }
+    }
 
+    // 哨兵划分（三数取中值）
+    fn partition(nums: []i32, left: usize, right: usize) usize {
+        // 选取三个候选元素的中位数
+        var med = medianThree(nums, left, (left + right) / 2, right);
+        // 将中位数交换至数组最左端
+        swap(nums, left, med);
+        // 以 nums[left] 作为基准数
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 从右向左找首个小于基准数的元素
+            while (i < j and nums[i] <= nums[left]) i += 1; // 从左向右找首个大于基准数的元素
+            swap(nums, i, j);   // 交换这两个元素
+        }
+        swap(nums, i, left);    // 将基准数交换至两子数组的分界线
+        return i;               // 返回基准数的索引
+    }
     ```
 
 ## 11.4.5. 尾递归优化
@@ -924,5 +981,22 @@ comments: true
 === "Zig"
 
     ```zig title="quick_sort.zig"
-
+    // 快速排序（尾递归优化）
+    fn quickSort(nums: []i32, left_: usize, right_: usize) void {
+        var left = left_;
+        var right = right_;
+        // 子数组长度为 1 时终止递归
+        while (left < right) {
+            // 哨兵划分操作
+            var pivot = partition(nums, left, right);
+            // 对两个子数组中较短的那个执行快排
+            if (pivot - left < right - pivot) {
+                quickSort(nums, left, pivot - 1);   // 递归排序左子数组
+                left = pivot + 1;                   // 剩余待排序区间为 [pivot + 1, right]
+            } else {
+                quickSort(nums, pivot + 1, right);  // 递归排序右子数组
+                right = pivot - 1;                  // 剩余待排序区间为 [left, pivot - 1]
+            }
+        }
+    }
     ```
diff --git a/chapter_stack_and_queue/queue.md b/chapter_stack_and_queue/queue.md
index faadf95ba..88b54aab7 100755
--- a/chapter_stack_and_queue/queue.md
+++ b/chapter_stack_and_queue/queue.md
@@ -842,7 +842,90 @@ comments: true
 === "Zig"
 
     ```zig title="linkedlist_queue.zig"
+    // 基于链表实现的队列
+    fn LinkedListQueue(comptime T: type) type {
+        return struct {
+            const Self = @This();
 
+            front: ?*inc.ListNode(T) = null,                // 头结点 front
+            rear: ?*inc.ListNode(T) = null,                 // 尾结点 rear
+            queSize: usize = 0,                             // 队列的长度
+            mem_arena: ?std.heap.ArenaAllocator = null,
+            mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
+
+            // 构造函数（分配内存+初始化队列）
+            pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
+                if (self.mem_arena == null) {
+                    self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                    self.mem_allocator = self.mem_arena.?.allocator();
+                }
+                self.front = null;
+                self.rear = null;
+                self.queSize = 0;
+            }
+
+            // 析构函数（释放内存）
+            pub fn deinit(self: *Self) void {
+                if (self.mem_arena == null) return;
+                self.mem_arena.?.deinit();
+            }
+
+            // 获取队列的长度
+            pub fn size(self: *Self) usize {
+                return self.queSize;
+            }
+
+            // 判断队列是否为空
+            pub fn isEmpty(self: *Self) bool {
+                return self.size() == 0;
+            }
+
+            // 访问队首元素
+            pub fn peek(self: *Self) T {
+                if (self.size() == 0) @panic("队列为空");
+                return self.front.?.val;
+            }  
+
+            // 入队
+            pub fn push(self: *Self, num: T) !void {
+                // 尾结点后添加 num
+                var node = try self.mem_allocator.create(inc.ListNode(T));
+                node.init(num);
+                // 如果队列为空，则令头、尾结点都指向该结点
+                if (self.front == null) {
+                    self.front = node;
+                    self.rear = node;
+                // 如果队列不为空，则将该结点添加到尾结点后
+                } else {
+                    self.rear.?.next = node;
+                    self.rear = node;
+                }
+                self.queSize += 1;
+            } 
+
+            // 出队
+            pub fn poll(self: *Self) T {
+                var num = self.peek();
+                // 删除头结点
+                self.front = self.front.?.next;
+                self.queSize -= 1;
+                return num;
+            } 
+
+            // 将链表转换为数组
+            pub fn toArray(self: *Self) ![]T {
+                var node = self.front;
+                var res = try self.mem_allocator.alloc(T, self.size());
+                std.mem.set(T, res, @as(T, 0));
+                var i: usize = 0;
+                while (i < res.len) : (i += 1) {
+                    res[i] = node.?.val;
+                    node = node.?.next;
+                }
+                return res;
+            }
+        };
+    }
     ```
 
 ### 基于数组的实现
@@ -1445,7 +1528,93 @@ comments: true
 === "Zig"
 
     ```zig title="array_queue.zig"
+    // 基于环形数组实现的队列
+    fn ArrayQueue(comptime T: type) type {
+        return struct {
+            const Self = @This();
 
+            nums: []T = undefined,                          // 用于存储队列元素的数组     
+            cap: usize = 0,                                 // 队列容量
+            front: usize = 0,                               // 队首指针，指向队首元素
+            queSize: usize = 0,                             // 尾指针，指向队尾 + 1
+            mem_arena: ?std.heap.ArenaAllocator = null,
+            mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
+
+            // 构造函数（分配内存+初始化数组）
+            pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {
+                if (self.mem_arena == null) {
+                    self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                    self.mem_allocator = self.mem_arena.?.allocator();
+                }
+                self.cap = cap;
+                self.nums = try self.mem_allocator.alloc(T, self.cap);
+                std.mem.set(T, self.nums, @as(T, 0));
+            }
+            
+            // 析构函数（释放内存）
+            pub fn deinit(self: *Self) void {
+                if (self.mem_arena == null) return;
+                self.mem_arena.?.deinit();
+            }
+
+            // 获取队列的容量
+            pub fn capacity(self: *Self) usize {
+                return self.cap;
+            }
+
+            // 获取队列的长度
+            pub fn size(self: *Self) usize {
+                return self.queSize;
+            }
+
+            // 判断队列是否为空
+            pub fn isEmpty(self: *Self) bool {
+                return self.queSize == 0;
+            }
+
+            // 入队
+            pub fn push(self: *Self, num: T) !void {
+                if (self.size() == self.capacity()) {
+                    std.debug.print("队列已满\n", .{});
+                    return;
+                }
+                // 计算尾指针，指向队尾索引 + 1
+                // 通过取余操作，实现 rear 越过数组尾部后回到头部
+                var rear = (self.front + self.queSize) % self.capacity();
+                // 尾结点后添加 num
+                self.nums[rear] = num;
+                self.queSize += 1;
+            } 
+
+            // 出队
+            pub fn poll(self: *Self) T {
+                var num = self.peek();
+                // 队首指针向后移动一位，若越过尾部则返回到数组头部
+                self.front = (self.front + 1) % self.capacity();
+                self.queSize -= 1;
+                return num;
+            } 
+
+            // 访问队首元素
+            pub fn peek(self: *Self) T {
+                if (self.isEmpty()) @panic("队列为空");
+                return self.nums[self.front];
+            } 
+
+            // 返回数组
+            pub fn toArray(self: *Self) ![]T {
+                // 仅转换有效长度范围内的列表元素
+                var res = try self.mem_allocator.alloc(T, self.size());
+                std.mem.set(T, res, @as(T, 0));
+                var i: usize = 0;
+                var j: usize = self.front;
+                while (i < self.size()) : ({ i += 1; j += 1; }) {
+                    res[i] = self.nums[j % self.capacity()];
+                }
+                return res;
+            }
+        };
+    }
     ```
 
 以上代码仍存在局限性，即长度不可变。然而，我们可以通过将数组替换为列表（即动态数组）来引入扩容机制，有兴趣的同学可以尝试实现。
diff --git a/chapter_stack_and_queue/stack.md b/chapter_stack_and_queue/stack.md
index cf0dbf376..8e81edb39 100755
--- a/chapter_stack_and_queue/stack.md
+++ b/chapter_stack_and_queue/stack.md
@@ -771,7 +771,79 @@ comments: true
 === "Zig"
 
     ```zig title="linkedlist_stack.zig"
+    // 基于链表实现的栈
+    fn LinkedListStack(comptime T: type) type {
+        return struct {
+            const Self = @This();
 
+            stackTop: ?*inc.ListNode(T) = null,             // 将头结点作为栈顶
+            stkSize: usize = 0,                             // 栈的长度
+            mem_arena: ?std.heap.ArenaAllocator = null,
+            mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
+
+            // 构造函数（分配内存+初始化栈）
+            pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
+                if (self.mem_arena == null) {
+                    self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                    self.mem_allocator = self.mem_arena.?.allocator();
+                }
+                self.stackTop = null;
+                self.stkSize = 0;
+            }
+
+            // 析构函数（释放内存）
+            pub fn deinit(self: *Self) void {
+                if (self.mem_arena == null) return;
+                self.mem_arena.?.deinit();
+            }
+
+            // 获取栈的长度
+            pub fn size(self: *Self) usize {
+                return self.stkSize;
+            }
+
+            // 判断栈是否为空
+            pub fn isEmpty(self: *Self) bool {
+                return self.size() == 0;
+            }
+
+            // 访问栈顶元素
+            pub fn top(self: *Self) T {
+                if (self.size() == 0) @panic("栈为空");
+                return self.stackTop.?.val;
+            }  
+
+            // 入栈
+            pub fn push(self: *Self, num: T) !void {
+                var node = try self.mem_allocator.create(inc.ListNode(T));
+                node.init(num);
+                node.next = self.stackTop;
+                self.stackTop = node;
+                self.stkSize += 1;
+            } 
+
+            // 出栈
+            pub fn pop(self: *Self) T {
+                var num = self.top();
+                self.stackTop = self.stackTop.?.next;
+                self.stkSize -= 1;
+                return num;
+            } 
+
+            // 将栈转换为数组
+            pub fn toArray(self: *Self) ![]T {
+                var node = self.stackTop;
+                var res = try self.mem_allocator.alloc(T, self.size());
+                std.mem.set(T, res, @as(T, 0));
+                var i: usize = 0;
+                while (i < res.len) : (i += 1) {
+                    res[res.len - i - 1] = node.?.val;
+                    node = node.?.next;
+                }
+                return res;
+            }
+        };
+    }
     ```
 
 ### 基于数组的实现
@@ -1178,7 +1250,59 @@ comments: true
 === "Zig"
 
     ```zig title="array_stack.zig"
+    // 基于数组实现的栈
+    fn ArrayStack(comptime T: type) type {
+        return struct {
+            const Self = @This();
 
+            stack: ?std.ArrayList(T) = null,     
+
+            // 构造函数（分配内存+初始化栈）
+            pub fn init(self: *Self, allocator: std.mem.Allocator) void {
+                if (self.stack == null) {
+                    self.stack = std.ArrayList(T).init(allocator);
+                }
+            }
+
+            // 析构函数（释放内存）
+            pub fn deinit(self: *Self) void {
+                if (self.stack == null) return;
+                self.stack.?.deinit();
+            }
+
+            // 获取栈的长度
+            pub fn size(self: *Self) usize {
+                return self.stack.?.items.len;
+            }
+
+            // 判断栈是否为空
+            pub fn isEmpty(self: *Self) bool {
+                return self.size() == 0;
+            }
+
+            // 访问栈顶元素
+            pub fn peek(self: *Self) T {
+                if (self.isEmpty()) @panic("栈为空");
+                return self.stack.?.items[self.size() - 1];
+            }  
+
+            // 入栈
+            pub fn push(self: *Self, num: T) !void {
+                try self.stack.?.append(num);
+            } 
+
+            // 出栈
+            pub fn pop(self: *Self) T {
+                var num = self.stack.?.pop();
+                return num;
+            } 
+
+            // 返回 ArrayList
+            pub fn toList(self: *Self) std.ArrayList(T) {
+                return self.stack.?;
+            }
+        };
+    }
     ```
 
 ## 5.1.3. 两种实现对比
diff --git a/chapter_tree/avl_tree.md b/chapter_tree/avl_tree.md
index 4f57c4263..45be7f0ab 100644
--- a/chapter_tree/avl_tree.md
+++ b/chapter_tree/avl_tree.md
@@ -303,7 +303,18 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Zig"
 
     ```zig title="avl_tree.zig"
+    // 获取结点高度
+    fn height(self: *Self, node: ?*inc.TreeNode(T)) i32 {
+        _ = self;
+        // 空结点高度为 -1 ，叶结点高度为 0
+        return if (node == null) -1 else node.?.height;
+    }
 
+    // 更新结点高度
+    fn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void {
+        // 结点高度等于最高子树高度 + 1
+        node.?.height = std.math.max(self.height(node.?.left), self.height(node.?.right)) + 1;
+    }
     ```
 
 ### 结点平衡因子
@@ -420,7 +431,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Zig"
 
     ```zig title="avl_tree.zig"
-
+    // 获取平衡因子
+    fn balanceFactor(self: *Self, node: ?*inc.TreeNode(T)) i32 {
+        // 空结点平衡因子为 0
+        if (node == null) return 0;
+        // 结点平衡因子 = 左子树高度 - 右子树高度
+        return self.height(node.?.left) - self.height(node.?.right);
+    }
     ```
 
 !!! note
@@ -608,7 +625,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Zig"
 
     ```zig title="avl_tree.zig"
-
+    // 右旋操作
+    fn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+        var child = node.?.left;
+        var grandChild = child.?.right;
+        // 以 child 为原点，将 node 向右旋转
+        child.?.right = node;
+        node.?.left = grandChild;
+        // 更新结点高度
+        self.updateHeight(node);
+        self.updateHeight(child);
+        // 返回旋转后子树的根结点
+        return child;
+    }
     ```
 
 ### Case 2 - 左旋
@@ -778,7 +807,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Zig"
 
     ```zig title="avl_tree.zig"
-
+    // 左旋操作
+    fn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+        var child = node.?.right;
+        var grandChild = child.?.left;
+        // 以 child 为原点，将 node 向左旋转
+        child.?.left = node;
+        node.?.right = grandChild;
+        // 更新结点高度
+        self.updateHeight(node);
+        self.updateHeight(child);
+        // 返回旋转后子树的根结点
+        return child;
+    }
     ```
 
 ### Case 3 - 先左后右
@@ -1100,7 +1141,35 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Zig"
 
     ```zig title="avl_tree.zig"
-
+    // 执行旋转操作，使该子树重新恢复平衡
+    fn rotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+        // 获取结点 node 的平衡因子
+        var balance_factor = self.balanceFactor(node);
+        // 左偏树
+        if (balance_factor > 1) {
+            if (self.balanceFactor(node.?.left) >= 0) {
+                // 右旋
+                return self.rightRotate(node);
+            } else {
+                // 先左旋后右旋
+                node.?.left = self.leftRotate(node.?.left);
+                return self.rightRotate(node);
+            }
+        }
+        // 右偏树
+        if (balance_factor < -1) {
+            if (self.balanceFactor(node.?.right) <= 0) {
+                // 左旋
+                return self.leftRotate(node);
+            } else {
+                // 先右旋后左旋
+                node.?.right = self.rightRotate(node.?.right);
+                return self.leftRotate(node);
+            }
+        }
+        // 平衡树，无需旋转，直接返回
+        return node;
+    }
     ```
 
 ## 7.4.3. AVL 树常用操作
@@ -1345,7 +1414,34 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Zig"
 
     ```zig title="avl_tree.zig"
+    // 插入结点
+    fn insert(self: *Self, val: T) !?*inc.TreeNode(T) {
+        self.root = try self.insertHelper(self.root, val);
+        return self.root;
+    }
 
+    // 递归插入结点（辅助函数）
+    fn insertHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) !?*inc.TreeNode(T) {
+        var node = node_;
+        if (node == null) {
+            var tmp_node = try self.mem_allocator.create(inc.TreeNode(T));
+            tmp_node.init(val);
+            return tmp_node;
+        }
+        // 1. 查找插入位置，并插入结点
+        if (val < node.?.val) {
+            node.?.left = try self.insertHelper(node.?.left, val);
+        } else if (val > node.?.val) {
+            node.?.right = try self.insertHelper(node.?.right, val);
+        } else {
+            return node;            // 重复结点不插入，直接返回
+        }
+        self.updateHeight(node);    // 更新结点高度
+        // 2. 执行旋转操作，使该子树重新恢复平衡
+        node = self.rotate(node);
+        // 返回子树的根结点
+        return node;
+    }
     ```
 
 ### 删除结点
@@ -1790,7 +1886,56 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Zig"
 
     ```zig title="avl_tree.zig"
+    // 删除结点
+    fn remove(self: *Self, val: T) ?*inc.TreeNode(T) {
+       self.root = self.removeHelper(self.root, val);
+        return self.root;
+    }
 
+    // 递归删除结点（辅助函数）
+    fn removeHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) ?*inc.TreeNode(T) {
+        var node = node_;
+        if (node == null) return null;
+        // 1. 查找结点，并删除之
+        if (val < node.?.val) {
+            node.?.left = self.removeHelper(node.?.left, val);
+        } else if (val > node.?.val) {
+            node.?.right = self.removeHelper(node.?.right, val);
+        } else {
+            if (node.?.left == null or node.?.right == null) {
+                var child = if (node.?.left != null) node.?.left else node.?.right;
+                // 子结点数量 = 0 ，直接删除 node 并返回
+                if (child == null) {
+                    return null;
+                // 子结点数量 = 1 ，直接删除 node
+                } else {
+                    node = child;
+                }
+            } else {
+                // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                var temp = self.getInOrderNext(node.?.right);
+                node.?.right = self.removeHelper(node.?.right, temp.?.val);
+                node.?.val = temp.?.val;
+            }
+        }
+        self.updateHeight(node);    // 更新结点高度
+        // 2. 执行旋转操作，使该子树重新恢复平衡
+        node = self.rotate(node);
+        // 返回子树的根结点
+        return node;
+    }
+
+    // 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况）
+    fn getInOrderNext(self: *Self, node_: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+        _ = self;
+        var node = node_;
+        if (node == null) return node;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (node.?.left != null) {
+            node = node.?.left;
+        }
+        return node;
+    }
     ```
 
 ### 查找结点
diff --git a/chapter_tree/binary_search_tree.md b/chapter_tree/binary_search_tree.md
index 298bc9044..cdf825125 100755
--- a/chapter_tree/binary_search_tree.md
+++ b/chapter_tree/binary_search_tree.md
@@ -217,7 +217,25 @@ comments: true
 === "Zig"
 
     ```zig title="binary_search_tree.zig"
-
+    // 查找结点
+    fn search(self: *Self, num: T) ?*inc.TreeNode(T) {
+        var cur = self.root;
+        // 循环查找，越过叶结点后跳出
+        while (cur != null) {
+            // 目标结点在 cur 的右子树中
+            if (cur.?.val < num) {
+                cur = cur.?.right;
+            // 目标结点在 cur 的左子树中
+            } else if (cur.?.val > num) {
+                cur = cur.?.left;
+            // 找到目标结点，跳出循环
+            } else {
+                break;
+            }
+        }
+        // 返回目标结点
+        return cur;
+    }
     ```
 
 ### 插入结点
@@ -490,7 +508,35 @@ comments: true
 === "Zig"
 
     ```zig title="binary_search_tree.zig"
-
+    // 插入结点
+    fn insert(self: *Self, num: T) !?*inc.TreeNode(T) {
+        // 若树为空，直接提前返回
+        if (self.root == null) return null;
+        var cur = self.root;
+        var pre: ?*inc.TreeNode(T) = null;
+        // 循环查找，越过叶结点后跳出
+        while (cur != null) {
+            // 找到重复结点，直接返回
+            if (cur.?.val == num) return null;
+            pre = cur;
+            // 插入位置在 cur 的右子树中
+            if (cur.?.val < num) {
+                cur = cur.?.right;
+            // 插入位置在 cur 的左子树中
+            } else {
+                cur = cur.?.left;
+            }
+        }
+        // 插入结点 val
+        var node = try self.mem_allocator.create(inc.TreeNode(T));
+        node.init(num);
+        if (pre.?.val < num) {
+            pre.?.right = node;
+        } else {
+            pre.?.left = node;
+        }
+        return node;
+    }
     ```
 
 为了插入结点，需要借助 **辅助结点 `pre`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
@@ -1024,7 +1070,61 @@ comments: true
 === "Zig"
 
     ```zig title="binary_search_tree.zig"
+    // 删除结点
+    fn remove(self: *Self, num: T) ?*inc.TreeNode(T) {
+        // 若树为空，直接提前返回
+        if (self.root == null) return null;
+        var cur = self.root;
+        var pre: ?*inc.TreeNode(T) = null;
+        // 循环查找，越过叶结点后跳出
+        while (cur != null) {
+            // 找到待删除结点，跳出循环
+            if (cur.?.val == num) break;
+            pre = cur;
+            // 待删除结点在 cur 的右子树中
+            if (cur.?.val < num) {
+                cur = cur.?.right;
+            // 待删除结点在 cur 的左子树中
+            } else {
+                cur = cur.?.left;
+            }
+        }
+        // 若无待删除结点，则直接返回
+        if (cur == null) return null;
+        // 子结点数量 = 0 or 1
+        if (cur.?.left == null or cur.?.right == null) {
+            // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+            var child = if (cur.?.left != null) cur.?.left else cur.?.right;
+            // 删除结点 cur
+            if (pre.?.left == cur) {
+                pre.?.left = child;
+            } else {
+                pre.?.right = child;
+            }
+        // 子结点数量 = 2
+        } else {
+            // 获取中序遍历中 cur 的下一个结点
+            var nex = self.getInOrderNext(cur.?.right);
+            var tmp = nex.?.val;
+            // 递归删除结点 nex
+            _ = self.remove(nex.?.val);
+            // 将 nex 的值复制给 cur
+            cur.?.val = tmp;
+        }
+        return cur;
+    }
 
+    // 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况）
+    fn getInOrderNext(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+        _ = self;
+        var node_tmp = node;
+        if (node_tmp == null) return null;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (node_tmp.?.left != null) {
+            node_tmp = node_tmp.?.left;
+        }
+        return node_tmp;
+    }
     ```
 
 ### 排序
diff --git a/chapter_tree/binary_tree_traversal.md b/chapter_tree/binary_tree_traversal.md
index b78b9a491..8804a5d6d 100755
--- a/chapter_tree/binary_tree_traversal.md
+++ b/chapter_tree/binary_tree_traversal.md
@@ -211,7 +211,33 @@ comments: true
 === "Zig"
 
     ```zig title="binary_tree_bfs.zig"
-
+    // 层序遍历
+    fn hierOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) {
+        // 初始化队列，加入根结点
+        const L = std.TailQueue(*inc.TreeNode(T));
+        var queue = L{};
+        var root_node = try mem_allocator.create(L.Node);
+        root_node.data = root;
+        queue.append(root_node); 
+        // 初始化一个列表，用于保存遍历序列
+        var list = std.ArrayList(T).init(std.heap.page_allocator);
+        while (queue.len > 0) {
+            var queue_node = queue.popFirst().?;    // 队列出队
+            var node = queue_node.data;
+            try list.append(node.val);              // 保存结点值
+            if (node.left != null) {
+                var tmp_node = try mem_allocator.create(L.Node);
+                tmp_node.data = node.left.?;
+                queue.append(tmp_node);             // 左子结点入队
+            }
+            if (node.right != null) {
+                var tmp_node = try mem_allocator.create(L.Node);
+                tmp_node.data = node.right.?;
+                queue.append(tmp_node);             // 右子结点入队
+            }        
+        }
+        return list;
+    }
     ```
 
 ## 7.2.2. 前序、中序、后序遍历
@@ -512,7 +538,32 @@ comments: true
 === "Zig"
 
     ```zig title="binary_tree_dfs.zig"
+    // 前序遍历
+    fn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：根结点 -> 左子树 -> 右子树
+        try list.append(root.?.val);
+        try preOrder(T, root.?.left);
+        try preOrder(T, root.?.right);
+    }
 
+    // 中序遍历
+    fn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 根结点 -> 右子树
+        try inOrder(T, root.?.left);
+        try list.append(root.?.val);
+        try inOrder(T, root.?.right);
+    }
+
+    // 后序遍历
+    fn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根结点
+        try postOrder(T, root.?.left);
+        try postOrder(T, root.?.right);
+        try list.append(root.?.val);
+    }
     ```
 
 !!! note