diff --git a/codes/zig/build.zig b/codes/zig/build.zig index 188e17b7..c5370075 100644 --- a/codes/zig/build.zig +++ b/codes/zig/build.zig @@ -280,6 +280,47 @@ pub fn build(b: *std.build.Builder) void { if (b.args) |args| run_cmd_binary_tree_bfs.addArgs(args); const run_step_binary_tree_bfs = b.step("run_binary_tree_bfs", "Run binary_tree_bfs"); run_step_binary_tree_bfs.dependOn(&run_cmd_binary_tree_bfs.step); + + // Source File: "chapter_tree/binary_tree_dfs.zig" + // Run Command: zig build run_binary_tree_dfs + const exe_binary_tree_dfs = b.addExecutable("binary_tree_dfs", "chapter_tree/binary_tree_dfs.zig"); + exe_binary_tree_dfs.addPackagePath("include", "include/include.zig"); + exe_binary_tree_dfs.setTarget(target); + exe_binary_tree_dfs.setBuildMode(mode); + exe_binary_tree_dfs.install(); + const run_cmd_binary_tree_dfs = exe_binary_tree_dfs.run(); + run_cmd_binary_tree_dfs.step.dependOn(b.getInstallStep()); + if (b.args) |args| run_cmd_binary_tree_dfs.addArgs(args); + const run_step_binary_tree_dfs = b.step("run_binary_tree_dfs", "Run binary_tree_dfs"); + run_step_binary_tree_dfs.dependOn(&run_cmd_binary_tree_dfs.step); + + // Section: "Binary Search Tree" + // Source File: "chapter_tree/binary_search_tree.zig" + // Run Command: zig build run_binary_search_tree + const exe_binary_search_tree = b.addExecutable("binary_search_tree", "chapter_tree/binary_search_tree.zig"); + exe_binary_search_tree.addPackagePath("include", "include/include.zig"); + exe_binary_search_tree.setTarget(target); + exe_binary_search_tree.setBuildMode(mode); + exe_binary_search_tree.install(); + const run_cmd_binary_search_tree = exe_binary_search_tree.run(); + run_cmd_binary_search_tree.step.dependOn(b.getInstallStep()); + if (b.args) |args| run_cmd_binary_search_tree.addArgs(args); + const run_step_binary_search_tree = b.step("run_binary_search_tree", "Run binary_search_tree"); + run_step_binary_search_tree.dependOn(&run_cmd_binary_search_tree.step); + + // Section: "AVL Tree" + // Source File: "chapter_tree/avl_tree.zig" + // Run Command: zig build run_avl_tree + const exe_avl_tree = b.addExecutable("avl_tree", "chapter_tree/avl_tree.zig"); + exe_avl_tree.addPackagePath("include", "include/include.zig"); + exe_avl_tree.setTarget(target); + exe_avl_tree.setBuildMode(mode); + exe_avl_tree.install(); + const run_cmd_avl_tree = exe_avl_tree.run(); + run_cmd_avl_tree.step.dependOn(b.getInstallStep()); + if (b.args) |args| run_cmd_avl_tree.addArgs(args); + const run_step_avl_tree = b.step("run_avl_tree", "Run avl_tree"); + run_step_avl_tree.dependOn(&run_cmd_avl_tree.step); // Section: "Heap" // Source File: "chapter_heap/heap.zig" diff --git a/codes/zig/chapter_tree/avl_tree.zig b/codes/zig/chapter_tree/avl_tree.zig new file mode 100644 index 00000000..cf2e5842 --- /dev/null +++ b/codes/zig/chapter_tree/avl_tree.zig @@ -0,0 +1,260 @@ +// File: avl_tree.zig +// Created Time: 2023-01-15 +// Author: sjinzh (sjinzh@gmail.com) + +const std = @import("std"); +const inc = @import("include"); + +// 平衡二叉树 +pub fn AVLTree(comptime T: type) type { + return struct { + const Self = @This(); + + root: ?*inc.TreeNode(T) = null, // 根节点 + 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(); + } + } + + // 析构函数 + pub fn deinit(self: *Self) void { + if (self.mem_arena == null) return; + self.mem_arena.?.deinit(); + } + + // 获取结点高度 + 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; + } + + // 获取平衡因子 + fn balanceFactor(self: *Self, node: ?*inc.TreeNode(T)) i32 { + // 空结点平衡因子为 0 + if (node == null) return 0; + // 结点平衡因子 = 左子树高度 - 右子树高度 + return self.height(node.?.left) - self.height(node.?.right); + } + + // 右旋操作 + 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; + } + + // 左旋操作 + 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; + } + + // 执行旋转操作，使该子树重新恢复平衡 + 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; + } + + // 插入结点 + 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; + } + + // 删除结点 + 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; + } + + // 查找结点 + fn search(self: *Self, val: T) ?*inc.TreeNode(T) { + var cur = self.root; + // 循环查找，越过叶结点后跳出 + while (cur != null) { + // 目标结点在 cur 的右子树中 + if (cur.?.val < val) { + cur = cur.?.right; + // 目标结点在 cur 的左子树中 + } else if (cur.?.val > val) { + cur = cur.?.left; + // 找到目标结点，跳出循环 + } else { + break; + } + } + // 返回目标结点 + return cur; + } + }; +} + +pub fn testInsert(comptime T: type, tree_: *AVLTree(T), val: T) !void { + var tree = tree_; + _ = try tree.insert(val); + std.debug.print("\n插入结点 {} 后，AVL 树为\n", .{val}); + try inc.PrintUtil.printTree(tree.root, null, false); +} + +pub fn testRemove(comptime T: type, tree_: *AVLTree(T), val: T) void { + var tree = tree_; + _ = tree.remove(val); + std.debug.print("\n删除结点 {} 后，AVL 树为\n", .{val}); + try inc.PrintUtil.printTree(tree.root, null, false); +} + +// Driver Code +pub fn main() !void { + // 初始化空 AVL 树 + var avl_tree = AVLTree(i32){}; + avl_tree.init(std.heap.page_allocator); + defer avl_tree.deinit(); + + // 插入结点 + // 请关注插入结点后，AVL 树是如何保持平衡的 + try testInsert(i32, &avl_tree, 1); + try testInsert(i32, &avl_tree, 2); + try testInsert(i32, &avl_tree, 3); + try testInsert(i32, &avl_tree, 4); + try testInsert(i32, &avl_tree, 5); + try testInsert(i32, &avl_tree, 8); + try testInsert(i32, &avl_tree, 7); + try testInsert(i32, &avl_tree, 9); + try testInsert(i32, &avl_tree, 10); + try testInsert(i32, &avl_tree, 6); + + // 插入重复结点 + try testInsert(i32, &avl_tree, 7); + + // 删除结点 + // 请关注删除结点后，AVL 树是如何保持平衡的 + testRemove(i32, &avl_tree, 8); // 删除度为 0 的结点 + testRemove(i32, &avl_tree, 5); // 删除度为 1 的结点 + testRemove(i32, &avl_tree, 4); // 删除度为 2 的结点 + + // 查找结点 + var node = avl_tree.search(7).?; + std.debug.print("\n查找到的结点对象为 {any}，结点值 = {}\n", .{node, node.val}); + + _ = try std.io.getStdIn().reader().readByte(); +} \ No newline at end of file diff --git a/codes/zig/chapter_tree/binary_search_tree.zig b/codes/zig/chapter_tree/binary_search_tree.zig new file mode 100644 index 00000000..e34feb33 --- /dev/null +++ b/codes/zig/chapter_tree/binary_search_tree.zig @@ -0,0 +1,190 @@ +// File: binary_search_tree.zig +// Created Time: 2023-01-15 +// Author: sjinzh (sjinzh@gmail.com) + +const std = @import("std"); +const inc = @import("include"); + +// 二叉搜索树 +pub fn BinarySearchTree(comptime T: type) type { + return struct { + const Self = @This(); + + root: ?*inc.TreeNode(T) = null, + mem_arena: ?std.heap.ArenaAllocator = null, + mem_allocator: std.mem.Allocator = undefined, // 内存分配器 + + // 构造函数 + pub fn init(self: *Self, allocator: std.mem.Allocator, nums: []T) !void { + if (self.mem_arena == null) { + self.mem_arena = std.heap.ArenaAllocator.init(allocator); + self.mem_allocator = self.mem_arena.?.allocator(); + } + std.sort.sort(T, nums, {}, comptime std.sort.asc(T)); // 排序数组 + self.root = try self.buildTree(nums, 0, nums.len - 1); // 构建二叉搜索树 + } + + // 析构函数 + pub fn deinit(self: *Self) void { + if (self.mem_arena == null) return; + self.mem_arena.?.deinit(); + } + + // 构建二叉搜索树 + fn buildTree(self: *Self, nums: []T, i: usize, j: usize) !?*inc.TreeNode(T) { + if (i > j) return null; + // 将数组中间结点作为根结点 + var mid = (i + j) / 2; + var node = try self.mem_allocator.create(inc.TreeNode(T)); + node.init(nums[mid]); + // 递归建立左子树和右子树 + if (mid >= 1) node.left = try self.buildTree(nums, i, mid - 1); + node.right = try self.buildTree(nums, mid + 1, j); + return node; + } + + // 获取二叉树根结点 + fn getRoot(self: *Self) ?*inc.TreeNode(T) { + return self.root; + } + + // 查找结点 + 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; + } + + // 插入结点 + 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; + } + + // 删除结点 + 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; + } + }; +} + +// Driver Code +pub fn main() !void { + // 初始化二叉树 + var nums = [_]i32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + var bst = BinarySearchTree(i32){}; + try bst.init(std.heap.page_allocator, &nums); + defer bst.deinit(); + std.debug.print("初始化的二叉树为\n", .{}); + try inc.PrintUtil.printTree(bst.getRoot(), null, false); + + // 查找结点 + var node = bst.search(7); + std.debug.print("\n查找到的结点对象为 {any}，结点值 = {}\n", .{node, node.?.val}); + + // 插入结点 + node = try bst.insert(16); + std.debug.print("\n插入结点 16 后，二叉树为\n", .{}); + try inc.PrintUtil.printTree(bst.getRoot(), null, false); + + // 删除结点 + _ = bst.remove(1); + std.debug.print("\n删除结点 1 后，二叉树为\n", .{}); + try inc.PrintUtil.printTree(bst.getRoot(), null, false); + _ = bst.remove(2); + std.debug.print("\n删除结点 2 后，二叉树为\n", .{}); + try inc.PrintUtil.printTree(bst.getRoot(), null, false); + _ = bst.remove(4); + std.debug.print("\n删除结点 4 后，二叉树为\n", .{}); + try inc.PrintUtil.printTree(bst.getRoot(), null, false); + + _ = try std.io.getStdIn().reader().readByte(); +} \ No newline at end of file diff --git a/codes/zig/chapter_tree/binary_tree_dfs.zig b/codes/zig/chapter_tree/binary_tree_dfs.zig new file mode 100644 index 00000000..dba49188 --- /dev/null +++ b/codes/zig/chapter_tree/binary_tree_dfs.zig @@ -0,0 +1,70 @@ +// File: binary_tree_dfs.zig +// Created Time: 2023-01-15 +// Author: sjinzh (sjinzh@gmail.com) + +const std = @import("std"); +const inc = @import("include"); + +var list = std.ArrayList(i32).init(std.heap.page_allocator); + +// 前序遍历 +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); +} + +// Driver Code +pub fn main() !void { + // 初始化内存分配器 + var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer mem_arena.deinit(); + const mem_allocator = mem_arena.allocator(); + + // 初始化二叉树 + // 这里借助了一个从数组直接生成二叉树的函数 + var nums = [_]i32{1, 2, 3, 4, 5, 6, 7}; + var root = try inc.TreeUtil.arrToTree(i32, mem_allocator, &nums); + std.debug.print("初始化二叉树\n", .{}); + try inc.PrintUtil.printTree(root, null, false); + + // 前序遍历 + list.clearRetainingCapacity(); + try preOrder(i32, root); + std.debug.print("\n前序遍历的结点打印序列 = ", .{}); + inc.PrintUtil.printList(i32, list); + + // 中序遍历 + list.clearRetainingCapacity(); + try inOrder(i32, root); + std.debug.print("\n中序遍历的结点打印序列 = ", .{}); + inc.PrintUtil.printList(i32, list); + + // 后序遍历 + list.clearRetainingCapacity(); + try postOrder(i32, root); + std.debug.print("\n后续遍历的结点打印序列 = ", .{}); + inc.PrintUtil.printList(i32, list); + + _ = try std.io.getStdIn().reader().readByte(); +} diff --git a/codes/zig/include/TreeNode.zig b/codes/zig/include/TreeNode.zig index 0e4f5b15..08e0ce64 100644 --- a/codes/zig/include/TreeNode.zig +++ b/codes/zig/include/TreeNode.zig @@ -10,13 +10,15 @@ pub fn TreeNode(comptime T: type) type { return struct { const Self = @This(); - val: T = undefined, - left: ?*Self = null, - right: ?*Self = null, + val: T = undefined, // 结点值 + height: i32 = undefined, // 结点高度 + left: ?*Self = null, // 左子结点指针 + right: ?*Self = null, // 右子结点指针 // Initialize a tree node with specific value pub fn init(self: *Self, x: i32) void { self.val = x; + self.height = 0; self.left = null; self.right = null; }