build

chapter_array_and_linkedlist/array.md

@@ -433,7 +433,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     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);
+        @memset(res, 0);
         // 将原数组中的所有元素复制到新数组
         std.mem.copy(i32, res, nums);
         // 返回扩展后的新数组
@@ -1077,7 +1077,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     ```zig title="array.zig"
     // 在数组中查找指定元素
     fn find(nums: []i32, target: i32) i32 {
-        for (nums) |num, i| {
+        for (nums, 0..) |num, i| {
             if (num == target) return @intCast(i32, i);
         }
         return -1;

chapter_array_and_linkedlist/list.md

@@ -1093,7 +1093,7 @@ comments: true
         extendRatio  int
     }
 
-    /* 构造方法 */
+    /* 构造函数 */
     func newMyList() *myList {
         return &myList{
             numsCapacity: 10,              // 列表容量
@@ -1716,23 +1716,23 @@ comments: true
             const Self = @This();
             
             nums: []T = undefined,                        // 数组（存储列表元素）
-            nums_capacity: usize = 10,                     // 列表容量
-            num_size: usize = 0,                           // 列表长度（即当前元素数量）
-            extend_ratio: usize = 2,                       // 每次列表扩容的倍数
+            numsCapacity: usize = 10,                     // 列表容量
+            numSize: usize = 0,                           // 列表长度（即当前元素数量）
+            extendRatio: usize = 2,                       // 每次列表扩容的倍数
             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.nums = try self.mem_allocator.alloc(T, self.nums_capacity);
-                std.mem.set(T, self.nums, @as(T, 0));
+                self.nums = try self.mem_allocator.alloc(T, self.numsCapacity);
+                @memset(self.nums, @as(T, 0));
             }
 
-            // 析构方法（释放内存）
+            // 析构函数（释放内存）
             pub fn deinit(self: *Self) void {
                 if (self.mem_arena == null) return;
                 self.mem_arena.?.deinit();
@@ -1740,12 +1740,12 @@ comments: true
 
             // 获取列表长度（即当前元素数量）
             pub fn size(self: *Self) usize {
-                return self.num_size;
+                return self.numSize;
             }
 
             // 获取列表容量
             pub fn capacity(self: *Self) usize {
-                return self.nums_capacity;
+                return self.numsCapacity;
             }
 
             // 访问元素
@@ -1768,7 +1768,7 @@ comments: true
                 if (self.size() == self.capacity()) try self.extendCapacity();
                 self.nums[self.size()] = num;
                 // 更新元素数量
-                self.num_size += 1;
+                self.numSize += 1;
             }  
 
             // 中间插入元素
@@ -1783,7 +1783,7 @@ comments: true
                 }
                 self.nums[index] = num;
                 // 更新元素数量
-                self.num_size += 1;
+                self.numSize += 1;
             }
 
             // 删除元素
@@ -1796,30 +1796,30 @@ comments: true
                     self.nums[j] = self.nums[j + 1];
                 }
                 // 更新元素数量
-                self.num_size -= 1;
+                self.numSize -= 1;
                 // 返回被删除元素
                 return num;
             }
 
             // 列表扩容
             pub fn extendCapacity(self: *Self) !void {
-                // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
-                var newCapacity = self.capacity() * self.extend_ratio;
+                // 新建一个长度为 size * extendRatio 的数组，并将原数组拷贝到新数组
+                var newCapacity = self.capacity() * self.extendRatio;
                 var extend = try self.mem_allocator.alloc(T, newCapacity);
-                std.mem.set(T, extend, @as(T, 0));
+                @memset(extend, @as(T, 0));
                 // 将原数组中的所有元素复制到新数组
                 std.mem.copy(T, extend, self.nums);
                 self.nums = extend;
                 // 更新列表容量
-                self.nums_capacity = newCapacity;
+                self.numsCapacity = newCapacity;
             }
 
             // 将列表转换为数组
             pub fn toArray(self: *Self) ![]T {
                 // 仅转换有效长度范围内的列表元素
                 var nums = try self.mem_allocator.alloc(T, self.size());
-                std.mem.set(T, nums, @as(T, 0));
-                for (nums) |*num, i| {
+               @memset(nums, @as(T, 0));
+                for (nums, 0..) |*num, i| {
                     num.* = self.get(i);
                 }
                 return nums;

chapter_backtracking/subset_sum_problem.md

@@ -127,7 +127,15 @@ comments: true
     ```go title="subset_sum_i_naive.go"
     [class]{}-[func]{backtrackINaive}
 
-    [class]{}-[func]{subsetSumINaive}
+    /* 求解子集和 I（包含重复子集） */
+    func subsetSumINaive(nums []int, target int) [][]int {
+        s := subset{}
+        state := make([]int, 0) // 状态（子集）
+        total := 0              // 子集和
+        res := make([][]int, 0) // 结果列表（子集列表）
+        s.backtrack(total, target, &state, &nums, &res)
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -157,9 +165,36 @@ comments: true
 === "C#"
 
     ```csharp title="subset_sum_i_naive.cs"
-    [class]{subset_sum_i_naive}-[func]{backtrack}
+    /* 回溯算法：子集和 I */
+    void backtrack(List<int> state, int target, int total, int[] choices, List<List<int>> res) {
+        // 子集和等于 target 时，记录解
+        if (total == target) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.Length; i++) {
+            // 剪枝：若子集和超过 target ，则跳过该选择
+            if (total + choices[i] > target) {
+                continue;
+            }
+            // 尝试：做出选择，更新元素和 total
+            state.Add(choices[i]);
+            // 进行下一轮选择
+            backtrack(state, target, total + choices[i], choices, res);
+            // 回退：撤销选择，恢复到之前的状态
+            state.RemoveAt(state.Count - 1);
+        }
+    }
 
-    [class]{subset_sum_i_naive}-[func]{subsetSumINaive}
+    /* 求解子集和 I（包含重复子集） */
+    List<List<int>> subsetSumINaive(int[] nums, int target) {
+        List<int> state = new List<int>(); // 状态（子集）
+        int total = 0; // 子集和
+        List<List<int>> res = new List<List<int>>(); // 结果列表（子集列表）
+        backtrack(state, target, total, nums, res);
+        return res;
+    }
     ```
 
 === "Swift"
@@ -331,7 +366,16 @@ comments: true
     ```go title="subset_sum_i.go"
     [class]{}-[func]{backtrackI}
 
-    [class]{}-[func]{subsetSumI}
+    /* 求解子集和 I */
+    func subsetSumI(nums []int, target int) [][]int {
+        s := subsetI{}
+        state := make([]int, 0) // 状态（子集）
+        sort.Ints(nums)         // 对 nums 进行排序
+        start := 0              // 遍历起始点
+        res := make([][]int, 0) // 结果列表（子集列表）
+        s.backtrack(start, target, &state, &nums, &res)
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -361,9 +405,39 @@ comments: true
 === "C#"
 
     ```csharp title="subset_sum_i.cs"
-    [class]{subset_sum_i}-[func]{backtrack}
+    /* 回溯算法：子集和 I */
+    void backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {
+        // 子集和等于 target 时，记录解
+        if (target == 0) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        // 剪枝二：从 start 开始遍历，避免生成重复子集
+        for (int i = start; i < choices.Length; i++) {
+            // 剪枝一：若子集和超过 target ，则直接结束循环
+            // 这是因为数组已排序，后边元素更大，子集和一定超过 target
+            if (target - choices[i] < 0) {
+                break;
+            }
+            // 尝试：做出选择，更新 target, start
+            state.Add(choices[i]);
+            // 进行下一轮选择
+            backtrack(state, target - choices[i], choices, i, res);
+            // 回退：撤销选择，恢复到之前的状态
+            state.RemoveAt(state.Count - 1);
+        }
+    }
 
-    [class]{subset_sum_i}-[func]{subsetSumI}
+    /* 求解子集和 I */
+    List<List<int>> subsetSumI(int[] nums, int target) {
+        List<int> state = new List<int>(); // 状态（子集）
+        Array.Sort(nums); // 对 nums 进行排序
+        int start = 0; // 遍历起始点
+        List<List<int>> res = new List<List<int>>(); // 结果列表（子集列表）
+        backtrack(state, target, nums, start, res);
+        return res;
+    }
     ```
 
 === "Swift"
@@ -542,7 +616,16 @@ comments: true
     ```go title="subset_sum_ii.go"
     [class]{}-[func]{backtrackII}
 
-    [class]{}-[func]{subsetSumII}
+    /* 求解子集和 II */
+    func subsetSumII(nums []int, target int) [][]int {
+        s := subsetII{}
+        state := make([]int, 0) // 状态（子集）
+        sort.Ints(nums)         // 对 nums 进行排序
+        start := 0              // 遍历起始点
+        res := make([][]int, 0) // 结果列表（子集列表）
+        s.backtrack(start, target, &state, &nums, &res)
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -572,9 +655,44 @@ comments: true
 === "C#"
 
     ```csharp title="subset_sum_ii.cs"
-    [class]{subset_sum_ii}-[func]{backtrack}
+    /* 回溯算法：子集和 II */
+    void backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {
+        // 子集和等于 target 时，记录解
+        if (target == 0) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        // 剪枝二：从 start 开始遍历，避免生成重复子集
+        // 剪枝三：从 start 开始遍历，避免重复选择同一元素
+        for (int i = start; i < choices.Length; i++) {
+            // 剪枝一：若子集和超过 target ，则直接结束循环
+            // 这是因为数组已排序，后边元素更大，子集和一定超过 target
+            if (target - choices[i] < 0) {
+                break;
+            }
+            // 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
+            if (i > start && choices[i] == choices[i - 1]) {
+                continue;
+            }
+            // 尝试：做出选择，更新 target, start
+            state.Add(choices[i]);
+            // 进行下一轮选择
+            backtrack(state, target - choices[i], choices, i + 1, res);
+            // 回退：撤销选择，恢复到之前的状态
+            state.RemoveAt(state.Count - 1);
+        }
+    }
 
-    [class]{subset_sum_ii}-[func]{subsetSumII}
+    /* 求解子集和 II */
+    List<List<int>> subsetSumII(int[] nums, int target) {
+        List<int> state = new List<int>(); // 状态（子集）
+        Array.Sort(nums); // 对 nums 进行排序
+        int start = 0; // 遍历起始点
+        List<List<int>> res = new List<List<int>>(); // 结果列表（子集列表）
+        backtrack(state, target, nums, start, res);
+        return res;
+    }
     ```
 
 === "Swift"

chapter_computational_complexity/summary.md

@@ -38,6 +38,8 @@ comments: true
     函数（function）可以独立被执行，所有参数都以显式传递。
     方法（method）与一个对象关联，方法被隐式传递给调用它的对象，方法能够对类的实例中包含的数据进行操作。
 
+    因此，C 和 Go 只有函数，Java 和 C# 只有方法，在 C++, Python 中取决于它是否属于一个类。
+
 !!! question "图片“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
 
     不是，该图片展示的是空间复杂度（即增长趋势），而不是占用空间的绝对大小。每个曲线都包含一个常数项，用来把所有曲线的取值范围压缩到一个视觉舒适的范围内。

chapter_graph/graph_operations.md

@@ -298,7 +298,7 @@ comments: true
         adjMat [][]int
     }
 
-    /* 构造方法 */
+    /* 构造函数 */
     func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
         // 添加顶点
         n := len(vertices)
@@ -1113,7 +1113,7 @@ comments: true
         adjList map[Vertex][]Vertex
     }
 
-    /* 构造方法 */
+    /* 构造函数 */
     func newGraphAdjList(edges [][]Vertex) *graphAdjList {
         g := &graphAdjList{
             adjList: make(map[Vertex][]Vertex),

chapter_hashing/hash_algorithm.md

@@ -77,7 +77,6 @@ index = hash(key) % capacity
         int hash = 0;
         final int MODULUS = 1000000007;
         for (char c : key.toCharArray()) {
-            System.out.println((int)c);
             hash ^= (int) c;
         }
         return hash & MODULUS;
@@ -178,13 +177,53 @@ index = hash(key) % capacity
 === "Go"
 
     ```go title="simple_hash.go"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    func addHash(key string) int {
+        var hash int64
+        var modulus int64
 
-    [class]{}-[func]{mulHash}
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = (hash + int64(b)) % modulus
+        }
+        return int(hash)
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 乘法哈希 */
+    func mulHash(key string) int {
+        var hash int64
+        var modulus int64
 
-    [class]{}-[func]{rotHash}
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = (31*hash + int64(b)) % modulus
+        }
+        return int(hash)
+    }
+
+    /* 异或哈希 */
+    func xorHash(key string) int {
+        hash := 0
+        modulus := 1000000007
+        for _, b := range []byte(key) {
+            fmt.Println(int(b))
+            hash ^= int(b)
+            hash = (31*hash + int(b)) % modulus
+        }
+        return hash & modulus
+    }
+
+    /* 旋转哈希 */
+    func rotHash(key string) int {
+        var hash int64
+        var modulus int64
+
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus
+        }
+        return int(hash)
+    }
     ```
 
 === "JavaScript"
@@ -452,7 +491,29 @@ $$
 === "Dart"
 
     ```dart title="built_in_hash.dart"
-
+    int num = 3;
+    int hashNum = num.hashCode;
+    // 整数 3 的哈希值为 34803
+    
+    bool bol = true;
+    int hashBol = bol.hashCode;
+    // 布尔值 true 的哈希值为 1231
+    
+    double dec = 3.14159;
+    int hashDec = dec.hashCode;
+    // 小数 3.14159 的哈希值为 2570631074981783
+    
+    String str = "Hello 算法";
+    int hashStr = str.hashCode;
+    // 字符串 Hello 算法 的哈希值为 468167534
+    
+    List arr = [12836, "小哈"];
+    int hashArr = arr.hashCode;
+    // 数组 [12836, 小哈] 的哈希值为 976512528
+    
+    ListNode obj = new ListNode(0);
+    int hashObj = obj.hashCode;
+    // 节点对象 Instance of 'ListNode' 的哈希值为 1033450432
     ```
 
 在大多数编程语言中，**只有不可变对象才可作为哈希表的 `key`** 。假如我们将列表（动态数组）作为 `key` ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 `value` 了。

chapter_hashing/hash_collision.md

@@ -372,7 +372,128 @@ comments: true
     ```go title="hash_map_chaining.go"
     [class]{pair}-[func]{}
 
-    [class]{hashMapChaining}-[func]{}
+    /* 链式地址哈希表 */
+    type hashMapChaining struct {
+        size        int      // 键值对数量
+        capacity    int      // 哈希表容量
+        loadThres   float64  // 触发扩容的负载因子阈值
+        extendRatio int      // 扩容倍数
+        buckets     [][]pair // 桶数组
+    }
+
+    /* 构造方法 */
+    func newHashMapChaining() *hashMapChaining {
+        buckets := make([][]pair, 4)
+        for i := 0; i < 4; i++ {
+            buckets[i] = make([]pair, 0)
+        }
+        return &hashMapChaining{
+            size:        0,
+            capacity:    4,
+            loadThres:   2 / 3.0,
+            extendRatio: 2,
+            buckets:     buckets,
+        }
+    }
+
+    /* 哈希函数 */
+    func (m *hashMapChaining) hashFunc(key int) int {
+        return key % m.capacity
+    }
+
+    /* 负载因子 */
+    func (m *hashMapChaining) loadFactor() float64 {
+        return float64(m.size / m.capacity)
+    }
+
+    /* 查询操作 */
+    func (m *hashMapChaining) get(key int) string {
+        idx := m.hashFunc(key)
+        bucket := m.buckets[idx]
+        // 遍历桶，若找到 key 则返回对应 val
+        for _, p := range bucket {
+            if p.key == key {
+                return p.val
+            }
+        }
+        // 若未找到 key 则返回空字符串
+        return ""
+    }
+
+    /* 添加操作 */
+    func (m *hashMapChaining) put(key int, val string) {
+        // 当负载因子超过阈值时，执行扩容
+        if m.loadFactor() > m.loadThres {
+            m.extend()
+        }
+        idx := m.hashFunc(key)
+        // 遍历桶，若遇到指定 key ，则更新对应 val 并返回
+        for _, p := range m.buckets[idx] {
+            if p.key == key {
+                p.val = val
+                return
+            }
+        }
+        // 若无该 key ，则将键值对添加至尾部
+        p := pair{
+            key: key,
+            val: val,
+        }
+        m.buckets[idx] = append(m.buckets[idx], p)
+        m.size += 1
+    }
+
+    /* 删除操作 */
+    func (m *hashMapChaining) remove(key int) {
+        idx := m.hashFunc(key)
+        // 遍历桶，从中删除键值对
+        for i, p := range m.buckets[idx] {
+            if p.key == key {
+                // 切片删除
+                m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)
+                break
+            }
+        }
+        m.size -= 1
+    }
+
+    /* 扩容哈希表 */
+    func (m *hashMapChaining) extend() {
+        // 暂存原哈希表
+        tmpBuckets := make([][]pair, len(m.buckets))
+        for i := 0; i < len(m.buckets); i++ {
+            tmpBuckets[i] = make([]pair, len(m.buckets[i]))
+            copy(tmpBuckets[i], m.buckets[i])
+        }
+        // 初始化扩容后的新哈希表
+        m.capacity *= m.extendRatio
+        m.buckets = make([][]pair, m.capacity)
+        for i := 0; i < m.capacity; i++ {
+            m.buckets[i] = make([]pair, 0)
+        }
+        m.size = 0
+        // 将键值对从原哈希表搬运至新哈希表
+        for _, bucket := range tmpBuckets {
+            for _, p := range bucket {
+                m.put(p.key, p.val)
+            }
+        }
+    }
+
+    /* 打印哈希表 */
+    func (m *hashMapChaining) print() {
+        var builder strings.Builder
+
+        for _, bucket := range m.buckets {
+            builder.WriteString("[")
+            for _, p := range bucket {
+                builder.WriteString(strconv.Itoa(p.key) + " -> " + p.val + " ")
+            }
+            builder.WriteString("]")
+            fmt.Println(builder.String())
+            builder.Reset()
+        }
+    }
     ```
 
 === "JavaScript"
@@ -426,9 +547,111 @@ comments: true
 === "Dart"
 
     ```dart title="hash_map_chaining.dart"
-    [class]{Pair}-[func]{}
+    /* 键值对 */
+    class Pair {
+      int key;
+      String val;
+      Pair(this.key, this.val);
+    }
 
-    [class]{HashMapChaining}-[func]{}
+    /* 链式地址哈希表 */
+    class HashMapChaining {
+      late int size; // 键值对数量
+      late int capacity; // 哈希表容量
+      late double loadThres; // 触发扩容的负载因子阈值
+      late int extendRatio; // 扩容倍数
+      late List<List<Pair>> buckets; // 桶数组
+
+      /* 构造方法 */
+      HashMapChaining() {
+        size = 0;
+        capacity = 4;
+        loadThres = 2 / 3.0;
+        extendRatio = 2;
+        buckets = List.generate(capacity, (_) => []);
+      }
+
+      /* 哈希函数 */
+      int hashFunc(int key) {
+        return key % capacity;
+      }
+
+      /* 负载因子 */
+      double loadFactor() {
+        return size / capacity;
+      }
+
+      /* 查询操作 */
+      String? get(int key) {
+        int index = hashFunc(key);
+        List<Pair> bucket = buckets[index];
+        // 遍历桶，若找到 key 则返回对应 val
+        for (Pair pair in bucket) {
+          if (pair.key == key) {
+            return pair.val;
+          }
+        }
+        // 若未找到 key 则返回 null
+        return null;
+      }
+
+      /* 添加操作 */
+      void put(int key, String val) {
+        // 当负载因子超过阈值时，执行扩容
+        if (loadFactor() > loadThres) {
+          extend();
+        }
+        int index = hashFunc(key);
+        List<Pair> bucket = buckets[index];
+        // 遍历桶，若遇到指定 key ，则更新对应 val 并返回
+        for (Pair pair in bucket) {
+          if (pair.key == key) {
+            pair.val = val;
+            return;
+          }
+        }
+        // 若无该 key ，则将键值对添加至尾部
+        Pair pair = Pair(key, val);
+        bucket.add(pair);
+        size++;
+      }
+
+      /* 删除操作 */
+      void remove(int key) {
+        int index = hashFunc(key);
+        List<Pair> bucket = buckets[index];
+        // 遍历桶，从中删除键值对
+        bucket.removeWhere((Pair pair) => pair.key == key);
+        size--;
+      }
+
+      /* 扩容哈希表 */
+      void extend() {
+        // 暂存原哈希表
+        List<List<Pair>> bucketsTmp = buckets;
+        // 初始化扩容后的新哈希表
+        capacity *= extendRatio;
+        buckets = List.generate(capacity, (_) => []);
+        size = 0;
+        // 将键值对从原哈希表搬运至新哈希表
+        for (List<Pair> bucket in bucketsTmp) {
+          for (Pair pair in bucket) {
+            put(pair.key, pair.val);
+          }
+        }
+      }
+
+      /* 打印哈希表 */
+      void printHashMap() {
+        for (List<Pair> bucket in buckets) {
+          List<String> res = [];
+          for (Pair pair in bucket) {
+            res.add("${pair.key} -> ${pair.val}");
+          }
+          print(res);
+        }
+      }
+    }
     ```
 
 !!! tip
@@ -836,7 +1059,137 @@ comments: true
     ```go title="hash_map_open_addressing.go"
     [class]{pair}-[func]{}
 
-    [class]{hashMapOpenAddressing}-[func]{}
+    /* 链式地址哈希表 */
+    type hashMapOpenAddressing struct {
+        size        int     // 键值对数量
+        capacity    int     // 哈希表容量
+        loadThres   float64 // 触发扩容的负载因子阈值
+        extendRatio int     // 扩容倍数
+        buckets     []pair  // 桶数组
+        removed     pair    // 删除标记
+    }
+
+    /* 构造方法 */
+    func newHashMapOpenAddressing() *hashMapOpenAddressing {
+        buckets := make([]pair, 4)
+        return &hashMapOpenAddressing{
+            size:        0,
+            capacity:    4,
+            loadThres:   2 / 3.0,
+            extendRatio: 2,
+            buckets:     buckets,
+            removed: pair{
+                key: -1,
+                val: "-1",
+            },
+        }
+    }
+
+    /* 哈希函数 */
+    func (m *hashMapOpenAddressing) hashFunc(key int) int {
+        return key % m.capacity
+    }
+
+    /* 负载因子 */
+    func (m *hashMapOpenAddressing) loadFactor() float64 {
+        return float64(m.size) / float64(m.capacity)
+    }
+
+    /* 查询操作 */
+    func (m *hashMapOpenAddressing) get(key int) string {
+        idx := m.hashFunc(key)
+        // 线性探测，从 index 开始向后遍历
+        for i := 0; i < m.capacity; i++ {
+            // 计算桶索引，越过尾部返回头部
+            j := (idx + 1) % m.capacity
+            // 若遇到空桶，说明无此 key ，则返回 null
+            if m.buckets[j] == (pair{}) {
+                return ""
+            }
+            // 若遇到指定 key ，则返回对应 val
+            if m.buckets[j].key == key && m.buckets[j] != m.removed {
+                return m.buckets[j].val
+            }
+        }
+        // 若未找到 key 则返回空字符串
+        return ""
+    }
+
+    /* 添加操作 */
+    func (m *hashMapOpenAddressing) put(key int, val string) {
+        // 当负载因子超过阈值时，执行扩容
+        if m.loadFactor() > m.loadThres {
+            m.extend()
+        }
+        idx := m.hashFunc(key)
+        // 线性探测，从 index 开始向后遍历
+        for i := 0; i < m.capacity; i++ {
+            // 计算桶索引，越过尾部返回头部
+            j := (idx + i) % m.capacity
+            // 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
+            if m.buckets[j] == (pair{}) || m.buckets[j] == m.removed {
+                m.buckets[j] = pair{
+                    key: key,
+                    val: val,
+                }
+                m.size += 1
+                return
+            }
+            // 若遇到指定 key ，则更新对应 val
+            if m.buckets[j].key == key {
+                m.buckets[j].val = val
+            }
+        }
+    }
+
+    /* 删除操作 */
+    func (m *hashMapOpenAddressing) remove(key int) {
+        idx := m.hashFunc(key)
+        // 遍历桶，从中删除键值对
+        // 线性探测，从 index 开始向后遍历
+        for i := 0; i < m.capacity; i++ {
+            // 计算桶索引，越过尾部返回头部
+            j := (idx + 1) % m.capacity
+            // 若遇到空桶，说明无此 key ，则直接返回
+            if m.buckets[j] == (pair{}) {
+                return
+            }
+            // 若遇到指定 key ，则标记删除并返回
+            if m.buckets[j].key == key {
+                m.buckets[j] = m.removed
+                m.size -= 1
+            }
+        }
+    }
+
+    /* 扩容哈希表 */
+    func (m *hashMapOpenAddressing) extend() {
+        // 暂存原哈希表
+        tmpBuckets := make([]pair, len(m.buckets))
+        copy(tmpBuckets, m.buckets)
+
+        // 初始化扩容后的新哈希表
+        m.capacity *= m.extendRatio
+        m.buckets = make([]pair, m.capacity)
+        m.size = 0
+        // 将键值对从原哈希表搬运至新哈希表
+        for _, p := range tmpBuckets {
+            if p != (pair{}) && p != m.removed {
+                m.put(p.key, p.val)
+            }
+        }
+    }
+
+    /* 打印哈希表 */
+    func (m *hashMapOpenAddressing) print() {
+        for _, p := range m.buckets {
+            if p != (pair{}) {
+                fmt.Println(strconv.Itoa(p.key) + " -> " + p.val)
+            } else {
+                fmt.Println("nil")
+            }
+        }
+    }
     ```
 
 === "JavaScript"
@@ -890,9 +1243,130 @@ comments: true
 === "Dart"
 
     ```dart title="hash_map_open_addressing.dart"
-    [class]{Pair}-[func]{}
+    /* 键值对 */
+    class Pair {
+      int key;
+      String val;
+      Pair(this.key, this.val);
+    }
 
-    [class]{HashMapOpenAddressing}-[func]{}
+    /* 开放寻址哈希表 */
+    class HashMapOpenAddressing {
+      late int _size; // 键值对数量
+      late int _capacity; // 哈希表容量
+      late double _loadThres; // 触发扩容的负载因子阈值
+      late int _extendRatio; // 扩容倍数
+      late List<Pair?> _buckets; // 桶数组
+      late Pair _removed; // 删除标记
+
+      /* 构造方法 */
+      HashMapOpenAddressing() {
+        _size = 0;
+        _capacity = 4;
+        _loadThres = 2.0 / 3.0;
+        _extendRatio = 2;
+        _buckets = List.generate(_capacity, (index) => null);
+        _removed = Pair(-1, "-1");
+      }
+
+      /* 哈希函数 */
+      int hashFunc(int key) {
+        return key % _capacity;
+      }
+
+      /* 负载因子 */
+      double loadFactor() {
+        return _size / _capacity;
+      }
+
+      /* 查询操作 */
+      String? get(int key) {
+        int index = hashFunc(key);
+        // 线性探测，从 index 开始向后遍历
+        for (int i = 0; i < _capacity; i++) {
+          // 计算桶索引，越过尾部返回头部
+          int j = (index + i) % _capacity;
+          // 若遇到空桶，说明无此 key ，则返回 null
+          if (_buckets[j] == null) return null;
+          // 若遇到指定 key ，则返回对应 val
+          if (_buckets[j]!.key == key && _buckets[j] != _removed)
+            return _buckets[j]!.val;
+        }
+        return null;
+      }
+
+      /* 添加操作 */
+      void put(int key, String val) {
+        // 当负载因子超过阈值时，执行扩容
+        if (loadFactor() > _loadThres) {
+          extend();
+        }
+        int index = hashFunc(key);
+        // 线性探测，从 index 开始向后遍历
+        for (int i = 0; i < _capacity; i++) {
+          // 计算桶索引，越过尾部返回头部
+          int j = (index + i) % _capacity;
+          // 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
+          if (_buckets[j] == null || _buckets[j] == _removed) {
+            _buckets[j] = new Pair(key, val);
+            _size += 1;
+            return;
+          }
+          // 若遇到指定 key ，则更新对应 val
+          if (_buckets[j]!.key == key) {
+            _buckets[j]!.val = val;
+            return;
+          }
+        }
+      }
+
+      /* 删除操作 */
+      void remove(int key) {
+        int index = hashFunc(key);
+        // 线性探测，从 index 开始向后遍历
+        for (int i = 0; i < _capacity; i++) {
+          // 计算桶索引，越过尾部返回头部
+          int j = (index + i) % _capacity;
+          // 若遇到空桶，说明无此 key ，则直接返回
+          if (_buckets[j] == null) {
+            return;
+          }
+          // 若遇到指定 key ，则标记删除并返回
+          if (_buckets[j]!.key == key) {
+            _buckets[j] = _removed;
+            _size -= 1;
+            return;
+          }
+        }
+      }
+
+      /* 扩容哈希表 */
+      void extend() {
+        // 暂存原哈希表
+        List<Pair?> bucketsTmp = _buckets;
+        // 初始化扩容后的新哈希表
+        _capacity *= _extendRatio;
+        _buckets = List.generate(_capacity, (index) => null);
+        _size = 0;
+        // 将键值对从原哈希表搬运至新哈希表
+        for (Pair? pair in bucketsTmp) {
+          if (pair != null && pair != _removed) {
+            put(pair.key, pair.val);
+          }
+        }
+      }
+
+      /* 打印哈希表 */
+      void printHashMap() {
+        for (Pair? pair in _buckets) {
+          if (pair != null) {
+            print("${pair.key} -> ${pair.val}");
+          } else {
+            print(null);
+          }
+        }
+      }
+    }
     ```
 
 ### 多次哈希

chapter_hashing/hash_map.md

@@ -1212,7 +1212,7 @@ index = hash(key) % capacity
         key: usize = undefined,
         val: []const u8 = undefined,
 
-        pub fn init(key: usize, val: []const u8) Pair {
+       pub fn init(key: usize, val: []const u8) Pair {
             return Pair {
                 .key = key,
                 .val = val,
@@ -1223,25 +1223,25 @@ index = hash(key) % capacity
     // 基于数组简易实现的哈希表
     fn ArrayHashMap(comptime T: type) type {
         return struct {
-            buckets: ?std.ArrayList(?T) = null,
+            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.buckets = std.ArrayList(?T).init(self.mem_allocator);
+                // 初始化一个长度为 100 的桶（数组）
+                self.bucket = std.ArrayList(?T).init(self.mem_allocator);
                 var i: i32 = 0;
                 while (i < 100) : (i += 1) {
-                    try self.buckets.?.append(null);
+                    try self.bucket.?.append(null);
                 }
             }
 
-            // 析构方法
+            // 析构函数
             pub fn deinit(self: *Self) void {
-                if (self.buckets != null) self.buckets.?.deinit();
+                if (self.bucket != null) self.bucket.?.deinit();
             }
 
             // 哈希函数
@@ -1253,7 +1253,7 @@ index = hash(key) % capacity
             // 查询操作
             pub fn get(self: *Self, key: usize) []const u8 {
                 var index = hashFunc(key);
-                var pair = self.buckets.?.items[index];
+                var pair = self.bucket.?.items[index];
                 return pair.?.val;
             }
 
@@ -1261,44 +1261,44 @@ index = hash(key) % capacity
             pub fn put(self: *Self, key: usize, val: []const u8) !void {
                 var pair = Pair.init(key, val);
                 var index = hashFunc(key);
-                self.buckets.?.items[index] = pair;
+                self.bucket.?.items[index] = pair;
             }
 
             // 删除操作
             pub fn remove(self: *Self, key: usize) !void {
                 var index = hashFunc(key);
                 // 置为 null ，代表删除
-                self.buckets.?.items[index] = null;
+                self.bucket.?.items[index] = null;
             }       
 
             // 获取所有键值对
-            pub fn pairSet(self: *Self) !*std.ArrayList(T) {
+            pub fn pairSet(self: *Self) !std.ArrayList(T) {
                 var entry_set = std.ArrayList(T).init(self.mem_allocator);
-                for (self.buckets.?.items) |item| {
+                for (self.bucket.?.items) |item| {
                     if (item == null) continue;
                     try entry_set.append(item.?);
                 }
-                return &entry_set;
+                return entry_set;
             }  
 
             // 获取所有键
-            pub fn keySet(self: *Self) !*std.ArrayList(usize) {
+            pub fn keySet(self: *Self) !std.ArrayList(usize) {
                 var key_set = std.ArrayList(usize).init(self.mem_allocator);
-                for (self.buckets.?.items) |item| {
+                for (self.bucket.?.items) |item| {
                     if (item == null) continue;
                     try key_set.append(item.?.key);
                 }
-                return &key_set;
+                return key_set;
             }  
 
             // 获取所有值
-            pub fn valueSet(self: *Self) !*std.ArrayList([]const u8) {
+            pub fn valueSet(self: *Self) !std.ArrayList([]const u8) {
                 var value_set = std.ArrayList([]const u8).init(self.mem_allocator);
-                for (self.buckets.?.items) |item| {
+                for (self.bucket.?.items) |item| {
                     if (item == null) continue;
                     try value_set.append(item.?.val);
                 }
-                return &value_set;
+                return value_set;
             }
 
             // 打印哈希表
@@ -1405,7 +1405,7 @@ index = hash(key) % capacity
 
 ## 6.1.3. &nbsp; 哈希冲突与扩容
 
-本质上看，哈希函数的作用是黄输入空间（`key` 范围）映射到输出空间（数组索引范围），而输入空间往往远大于输出空间。因此，**理论上一定存在“多个输入对应相同输出”的情况**。
+本质上看，哈希函数的作用是将输入空间（`key` 范围）映射到输出空间（数组索引范围），而输入空间往往远大于输出空间。因此，**理论上一定存在“多个输入对应相同输出”的情况**。
 
 对于上述示例中的哈希函数，当输入的 `key` 后两位相同时，哈希函数的输出结果也相同。例如，查询学号为 12836 和 20336 的两个学生时，我们得到：
 

chapter_hashing/summary.md

@@ -17,3 +17,33 @@ comments: true
 - 哈希算法通常采用大质数作为模数，以最大化地保证哈希值的均匀分布，减少哈希冲突。
 - 常见的哈希算法包括 MD5, SHA-1, SHA-2, SHA3 等。MD5 常用语校验文件完整性，SHA-2 常用于安全应用与协议。
 - 编程语言通常会为数据类型提供内置哈希算法，用于计算哈希表中的桶索引。通常情况下，只有不可变对象是可哈希的。
+
+## 6.4.1.   Q & A
+
+!!! question "哈希表的时间复杂度为什么不是 $O(n)$ ？"
+
+    当哈希冲突比较严重时，哈希表的时间复杂度会退化至 $O(n)$ 。当哈希函数设计的比较好、容量设置比较合理、冲突比较平均时，时间复杂度是 $O(1)$ 。我们使用编程语言内置的哈希表时，通常认为时间复杂度是 $O(1)$ 。
+
+!!! question "为什么不使用哈希函数 $f(x) = x$ 呢？这样就不会有冲突了"
+
+    在 $f(x) = x$ 哈希函数下，每个元素对应唯一的桶索引，这与数组等价。然而，输入空间通常远大于输出空间（数组长度），因此哈希函数的最后一步往往是对数组长度取模。换句话说，哈希表的目标是将一个较大的状态空间映射到一个较小的空间，并提供 $O(1)$ 的查询效率。
+
+!!! question "哈希表底层实现是数组、链表、二叉树，但为什么效率可以比他们更高呢？"
+
+    首先，哈希表的时间效率变高，但空间效率变低了。哈希表有相当一部分的内存是未使用的，
+    
+    其次，只是在特定使用场景下时间效率变高了。如果一个功能能够在相同的时间复杂度下使用数组或链表实现，那么通常比哈希表更快。这是因为哈希函数计算需要开销，时间复杂度的常数项更大。
+    
+    最后，哈希表的时间复杂度可能发生劣化。例如在链式地址中，我们采取在链表或红黑树中执行查找操作，仍然有退化至 $O(n)$ 时间的风险。
+
+!!! question "多次哈希有不能直接删除元素的缺陷吗？对于标记已删除的空间，这个空间还能再次使用吗？"
+
+    多次哈希是开放寻址的一种，开放寻址法都有不能直接删除元素的缺陷，需要通过标记删除。被标记为已删除的空间是可以再次被使用的。当将新元素插入哈希表，并且通过哈希函数找到了被标记为已删除的位置时，该位置可以被新的元素使用。这样做既能保持哈希表的探测序列不变，又能保证哈希表的空间使用率。
+
+!!! question "为什么在线性探测中，查找元素的时候会出现哈希冲突呢？"
+
+    查找的时候通过哈希函数找到对应的桶和键值对，发现 `key` 不匹配，这就代表有哈希冲突。因此，线性探测法会根据预先设定的步长依次向下查找，直至找到正确的键值对或无法找到跳出为止。
+
+!!! question "为什么哈希表扩容能够缓解哈希冲突？"
+
+    哈希函数的最后一步往往是对数组长度 $n$ 取余，让输出值落入在数组索引范围；在扩容后，数组长度 $n$ 发生变化，而 `key` 对应的索引也可能发生变化。原先落在同一个桶的多个 `key` ，在扩容后可能会被分配到多个桶中，从而实现哈希冲突的缓解。

chapter_heap/build_heap.md

@@ -59,7 +59,7 @@ comments: true
 === "Go"
 
     ```go title="my_heap.go"
-    /* 构造方法，根据切片建堆 */
+    /* 构造函数，根据切片建堆 */
     func newMaxHeap(nums []any) *maxHeap {
         // 将列表元素原封不动添加进堆
         h := &maxHeap{data: nums}

chapter_heap/summary.md

@@ -10,3 +10,10 @@ comments: true
 - 完全二叉树非常适合用数组表示，因此我们通常使用数组来存储堆。
 - 堆化操作用于维护堆的性质，在入堆和出堆操作中都会用到。
 - 输入 $n$ 个元素并建堆的时间复杂度可以优化至 $O(n)$ ，非常高效。
+- Top-K 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 $O(n \log k)$ 。
+
+## 8.4.1.   Q & A
+
+!!! question "数据结构的“堆”与内存管理的“堆”是同一个概念吗？"
+
+    两者不是同一个概念，只是碰巧都叫堆。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄露。相较于栈内存，堆内存的管理和使用需要更谨慎，不恰当的使用可能会导致内存泄露和野指针等问题。

chapter_sorting/radix_sort.md

@@ -535,7 +535,7 @@ $$
         // defer mem_arena.deinit();
         const mem_allocator = mem_arena.allocator();
         var counter = try mem_allocator.alloc(usize, 10);
-        std.mem.set(usize, counter, 0);
+        @memset(counter, 0);
         var n = nums.len;
         // 统计 0~9 各数字的出现次数
         for (nums) |num| {

chapter_sorting/summary.md

@@ -20,6 +20,14 @@ comments: true
 
 ## 11.11.1.   Q & A
 
+!!! question "排序算法稳定性在什么情况下是必须的？"
+
+    在现实中，我们有可能是在对象的某个属性上进行排序。例如，学生有姓名和身高两个属性，我们希望实现一个多级排序/
+
+    先按照姓名进行排序，得到 `(A, 180) (B, 185) (C, 170) (D, 170)` ；接下来对身高进行排序。由于排序算法不稳定，我们可能得到 `(D, 170) (C, 170) (A, 180) (B, 185)` 。
+
+    可以发现，学生 D 和 C 的位置发生了交换，姓名的有序性被破坏了，而这是我们不希望看到的。
+
 !!! question "哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？"
 
     不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。
@@ -29,3 +37,13 @@ comments: true
     举个例子，给定数组 `[0, 0, 0, 0, 1]` ，如果先“从左向右查找”，哨兵划分后数组为 `[1, 0, 0, 0, 0]` ，这个结果是不正确的。
 
     再深入思考一下，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。
+
+!!! question "关于尾递归优化，为什么选短的数组能保证递归深度不超过 $log n$ ？"
+
+    递归深度就是当前未返回的递归方法的数量。每轮哨兵划分我们将原数组划分为两个子数组。在尾递归优化后，向下递归的子数组长度最大为原数组的一半长度。假设最差情况，一直为一半长度，那么最终的递归深度就是 $log n$ 。
+    
+    回顾原始的快速排序，我们有可能会连续地递归长度较大的数组，最差情况下为 $n, n - 1, n - 2, ..., 2, 1$ ，从而递归深度为 $n$ 。尾递归优化可以避免这种情况的出现。
+
+!!! question "桶排序的最差时间复杂度为什么是 $O(n^2)$ ？"
+
+    最差情况下，所有元素被分至同一个桶中。如果我们采用一个 $O(n^2)$ 算法来排序这些元素，则时间复杂度为 $O(n^2)$ 。

chapter_stack_and_queue/deque.md

@@ -1537,7 +1537,7 @@ comments: true
             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);
@@ -1548,7 +1548,7 @@ comments: true
                 self.que_size = 0;
             }
 
-            // 析构方法（释放内存）
+            // 析构函数（释放内存）
             pub fn deinit(self: *Self) void {
                 if (self.mem_arena == null) return;
                 self.mem_arena.?.deinit();
@@ -1653,7 +1653,7 @@ comments: true
             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));
+                @memset(res, @as(T, 0));
                 var i: usize = 0;
                 while (i < res.len) : (i += 1) {
                     res[i] = node.?.val;

chapter_stack_and_queue/queue.md

@@ -941,11 +941,11 @@ comments: true
 
             front: ?*inc.ListNode(T) = null,                // 头节点 front
             rear: ?*inc.ListNode(T) = null,                 // 尾节点 rear
-            que_size: usize = 0,                             // 队列的长度
+            que_size: 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);
@@ -956,7 +956,7 @@ comments: true
                 self.que_size = 0;
             }
 
-            // 析构方法（释放内存）
+            // 析构函数（释放内存）
             pub fn deinit(self: *Self) void {
                 if (self.mem_arena == null) return;
                 self.mem_arena.?.deinit();
@@ -1008,7 +1008,7 @@ comments: true
             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));
+                @memset(res, @as(T, 0));
                 var i: usize = 0;
                 while (i < res.len) : (i += 1) {
                     res[i] = node.?.val;
@@ -1775,11 +1775,11 @@ comments: true
             nums: []T = undefined,                          // 用于存储队列元素的数组     
             cap: usize = 0,                                 // 队列容量
             front: usize = 0,                               // 队首指针，指向队首元素
-            que_size: usize = 0,                             // 尾指针，指向队尾 + 1
+            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);
@@ -1787,10 +1787,10 @@ comments: true
                 }
                 self.cap = cap;
                 self.nums = try self.mem_allocator.alloc(T, self.cap);
-                std.mem.set(T, self.nums, @as(T, 0));
+                @memset(self.nums, @as(T, 0));
             }
             
-            // 析构方法（释放内存）
+            // 析构函数（释放内存）
             pub fn deinit(self: *Self) void {
                 if (self.mem_arena == null) return;
                 self.mem_arena.?.deinit();
@@ -1803,12 +1803,12 @@ comments: true
 
             // 获取队列的长度
             pub fn size(self: *Self) usize {
-                return self.que_size;
+                return self.queSize;
             }
 
             // 判断队列是否为空
             pub fn isEmpty(self: *Self) bool {
-                return self.que_size == 0;
+                return self.queSize == 0;
             }
 
             // 入队
@@ -1819,10 +1819,10 @@ comments: true
                 }
                 // 计算尾指针，指向队尾索引 + 1
                 // 通过取余操作，实现 rear 越过数组尾部后回到头部
-                var rear = (self.front + self.que_size) % self.capacity();
-                // 将 num 添加至队尾
+                var rear = (self.front + self.queSize) % self.capacity();
+                // 尾节点后添加 num
                 self.nums[rear] = num;
-                self.que_size += 1;
+                self.queSize += 1;
             } 
 
             // 出队
@@ -1830,7 +1830,7 @@ comments: true
                 var num = self.peek();
                 // 队首指针向后移动一位，若越过尾部则返回到数组头部
                 self.front = (self.front + 1) % self.capacity();
-                self.que_size -= 1;
+                self.queSize -= 1;
                 return num;
             } 
 
@@ -1844,7 +1844,7 @@ comments: true
             pub fn toArray(self: *Self) ![]T {
                 // 仅转换有效长度范围内的列表元素
                 var res = try self.mem_allocator.alloc(T, self.size());
-                std.mem.set(T, res, @as(T, 0));
+                @memset(res, @as(T, 0));
                 var i: usize = 0;
                 var j: usize = self.front;
                 while (i < self.size()) : ({ i += 1; j += 1; }) {

chapter_stack_and_queue/stack.md

@@ -862,9 +862,9 @@ comments: true
             stack_top: ?*inc.ListNode(T) = null,             // 将头节点作为栈顶
             stk_size: usize = 0,                             // 栈的长度
             mem_arena: ?std.heap.ArenaAllocator = null,
-            mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
+            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);
@@ -874,7 +874,7 @@ comments: true
                 self.stk_size = 0;
             }
 
-            // 析构方法（释放内存）
+            // 析构函数（释放内存）
             pub fn deinit(self: *Self) void {
                 if (self.mem_arena == null) return;
                 self.mem_arena.?.deinit();
@@ -917,7 +917,7 @@ comments: true
             pub fn toArray(self: *Self) ![]T {
                 var node = self.stack_top;
                 var res = try self.mem_allocator.alloc(T, self.size());
-                std.mem.set(T, res, @as(T, 0));
+                @memset(res, @as(T, 0));
                 var i: usize = 0;
                 while (i < res.len) : (i += 1) {
                     res[res.len - i - 1] = node.?.val;

chapter_tree/avl_tree.md

@@ -1478,7 +1478,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
         t.root = t.insertHelper(t.root, val)
     }
 
-    /* 递归插入节点（辅助方法） */
+    /* 递归插入节点（辅助函数） */
     func (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {
         if node == nil {
             return NewTreeNode(val)
@@ -1560,7 +1560,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
         tree->root = insertHelper(tree->root, val);
     }
 
-    /* 递归插入节点（辅助方法） */
+    /* 递归插入节点（辅助函数） */
     TreeNode *insertHelper(TreeNode *node, int val) {
         if (node == NULL) {
             return newTreeNode(val);
@@ -1644,8 +1644,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
 
     ```zig title="avl_tree.zig"
     // 插入节点
-    fn insert(self: *Self, val: T) void {
-        self.root = try self.insertHelper(self.root, val);
+    fn insert(self: *Self, val: T) !void {
+        self.root = (try self.insertHelper(self.root, val)).?;
     }
 
     // 递归插入节点（辅助方法）
@@ -1841,7 +1841,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
         t.root = t.removeHelper(t.root, val)
     }
 
-    /* 递归删除节点（辅助方法） */
+    /* 递归删除节点（辅助函数） */
     func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
         if node == nil {
             return nil
@@ -1976,7 +1976,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
         TreeNode *root = removeHelper(tree->root, val);
     }
 
-    /* 递归删除节点（辅助方法） */
+    /* 递归删除节点（辅助函数） */
     TreeNode *removeHelper(TreeNode *node, int val) {
         TreeNode *child, *grandChild;
         if (node == NULL) {
@@ -2117,7 +2117,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
     ```zig title="avl_tree.zig"
     // 删除节点
     fn remove(self: *Self, val: T) void {
-       self.root = self.removeHelper(self.root, val);
+       self.root = self.removeHelper(self.root, val).?;
     }
 
     // 递归删除节点（辅助方法）

chapter_tree/binary_search_tree.md

@@ -622,23 +622,22 @@ comments: true
 
 与插入节点类似，我们需要在删除操作后维持二叉搜索树的“左子树 < 根节点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除节点。接下来，根据待删除节点的子节点数量，删除操作需分为三种情况：
 
-当待删除节点的子节点数量 $= 0$ 时，表示待删除节点是叶节点，可以直接删除。
+当待删除节点的度为 $0$ 时，表示待删除节点是叶节点，可以直接删除。
 
 ![在二叉搜索树中删除节点（度为 0）](binary_search_tree.assets/bst_remove_case1.png)
 
 <p align="center"> Fig. 在二叉搜索树中删除节点（度为 0） </p>
 
-当待删除节点的子节点数量 $= 1$ 时，将待删除节点替换为其子节点即可。
+当待删除节点的度为 $1$ 时，将待删除节点替换为其子节点即可。
 
 ![在二叉搜索树中删除节点（度为 1）](binary_search_tree.assets/bst_remove_case2.png)
 
 <p align="center"> Fig. 在二叉搜索树中删除节点（度为 1） </p>
 
-当待删除节点的子节点数量 $= 2$ 时，删除操作分为三步：
+当待删除节点的度为 $2$ 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 $<$ 根 $<$ 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。假设我们选择右子树的最小节点（或者称为中序遍历的下个节点），则删除操作为：
 
 1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 `tmp` ；
-2. 在树中递归删除节点 `tmp` ；
-3. 用 `tmp` 的值覆盖待删除节点的值；
+2. 将 `tmp` 的值覆盖待删除节点的值，并在树中递归删除节点 `tmp` ；
 
 === "<1>"
     ![二叉搜索树删除节点示例](binary_search_tree.assets/bst_remove_case3_step1.png)
@@ -1167,7 +1166,7 @@ comments: true
 
     ```zig title="binary_search_tree.zig"
     // 删除节点
-    fn remove(self: *Self, num: T) !void {
+    fn remove(self: *Self, num: T) void {
         // 若树为空，直接提前返回
         if (self.root == null) return;
         var cur = self.root;
@@ -1204,11 +1203,11 @@ comments: true
             while (tmp.?.left != null) {
                 tmp = tmp.?.left;
             }
-            var tmpVal = tmp.?.val;
+            var tmp_val = tmp.?.val;
             // 递归删除节点 tmp
-            _ = self.remove(tmp.?.val);
+            self.remove(tmp.?.val);
             // 用 tmp 覆盖 cur
-            cur.?.val = tmpVal;
+            cur.?.val = tmp_val;
         }
     }
     ```

chapter_tree/summary.md

@@ -15,3 +15,25 @@ comments: true
 - 二叉搜索树是一种高效的元素查找数据结构，其查找、插入和删除操作的时间复杂度均为 $O(\log n)$ 。当二叉搜索树退化为链表时，各项时间复杂度会劣化至 $O(n)$ 。
 - AVL 树，也称为平衡二叉搜索树，它通过旋转操作，确保在不断插入和删除节点后，树仍然保持平衡。
 - AVL 树的旋转操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或删除节点后，AVL 树会从底向顶执行旋转操作，使树重新恢复平衡。
+
+## 7.6.1.   Q & A
+
+!!! question "对于只有一个节点的二叉树，树的高度和根节点的深度都是 $0$ 吗？"
+
+    是的，因为高度和深度通常定义为“走过边的数量”。
+
+!!! question "二叉树中的插入与删除一般都是由一套操作配合完成的，这里的“一套操作”指什么呢？可以理解为资源的子节点的资源释放吗？"
+
+    拿二叉搜索树来举例，删除节点操作要分为三种情况处理，其中每种情况都需要进行多个步骤的节点操作。
+
+!!! question "为什么 DFS 遍历二叉树有前、中、后三种顺序，分别有什么用呢？"
+
+    DFS 的前、中、后序遍历和访问数组的顺序类似，是遍历二叉树的基本方法，利用这三种遍历方法，我们可以得到一个特定顺序的遍历结果。例如在二叉搜索树中，由于结点大小满足 `左子结点值 < 根结点值 < 右子结点值` ，因此我们只要按照 `左->根->右` 的优先级遍历树，就可以获得有序的节点序列。
+
+!!! question "右旋操作是处理失衡节点 `node` , `child` , `grand_child` 之间的关系，那 `node` 的父节点和 `node` 原来的连接不需要维护吗？右旋操作后岂不是断掉了？"
+
+    我们需要从递归的视角来看这个问题。右旋操作 `right_rotate(root)` 传入的是子树的根节点，最终 `return child` 返回旋转之后的子树的根节点。子树的根节点和其父节点的连接是在该函数返回后完成的，不属于右旋操作的维护范围。
+
+!!! question "在 C++ 中，函数被划分到 `private` 和 `public` 中，这方面有什么考量吗？为什么要将 `height()` 函数和 `updateHeight()` 函数分别放在 `public` 和 `private` 中呢？"
+
+    主要看方法的使用范围，如果方法只在类内部使用，那么就设计为 `private` 。例如，用户单独调用 `updateHeight()` 是没有意义的，它只是插入、删除操作中的一步。而 `height()` 是访问结点高度，类似于 `vector.size()` ，因此设置成 `public` 以便使用。