build

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;
+    }
     ```
 
 ### 查找结点

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;
+    }
     ```
 
 ### 排序

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