CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-03 22:24:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Replace 结点 with 节点 (#452)

Browse Source 
* Replace 结点 with 节点
Update the footnotes in the figures

* Update mindmap

* Reduce the size of the mindmap.png
This commit is contained in:
Yudong Jin
2023-04-09 04:32:17 +08:00
committed by GitHub
parent 3f4e32b2b0
commit 1c8b7ef559
395 changed files with 2056 additions and 2056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
codes/zig/chapter_array_and_linkedlist/linked_list.zig
View File

@@ -5,14 +5,14 @@
const std = @import("std");
const inc = @import("include");
// 在链表的结点 n0 之后插入结点 P
// 在链表的节点 n0 之后插入节点 P
pub fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
P.?.next = n1;
n0.?.next = P;
}
// 删除链表的结点 n0 之后的首个结点
// 删除链表的节点 n0 之后的首个节点
pub fn remove(n0: ?*inc.ListNode(i32)) void {
if (n0.?.next == null) return;
// n0 -> P -> n1
@@ -21,7 +21,7 @@ pub fn remove(n0: ?*inc.ListNode(i32)) void {
n0.?.next = n1;
}
// 访问链表中索引为 index 的结点
// 访问链表中索引为 index 的节点
pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
var i: i32 = 0;
@@ -32,7 +32,7 @@ pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
return head;
}
// 在链表中查找值为 target 的首个结点
// 在链表中查找值为 target 的首个节点
pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
var index: i32 = 0;
@@ -47,7 +47,7 @@ pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
// Driver Code
pub fn main() !void {
// 初始化链表
// 初始化各个结点
// 初始化各个节点
var n0 = inc.ListNode(i32){.val = 1};
var n1 = inc.ListNode(i32){.val = 3};
var n2 = inc.ListNode(i32){.val = 2};
@@ -61,24 +61,24 @@ pub fn main() !void {
std.debug.print("初始化的链表为", .{});
try inc.PrintUtil.printLinkedList(i32, &n0);
// 插入结点
// 插入节点
var tmp = inc.ListNode(i32){.val = 0};
insert(&n0, &tmp);
std.debug.print("插入结点后的链表为", .{});
std.debug.print("插入节点后的链表为", .{});
try inc.PrintUtil.printLinkedList(i32, &n0);
// 删除结点
// 删除节点
remove(&n0);
std.debug.print("删除结点后的链表为", .{});
std.debug.print("删除节点后的链表为", .{});
try inc.PrintUtil.printLinkedList(i32, &n0);
// 访问结点
// 访问节点
var node = access(&n0, 3);
std.debug.print("链表中索引 3 处的结点的值 = {}\n", .{node.?.val});
std.debug.print("链表中索引 3 处的节点的值 = {}\n", .{node.?.val});
// 查找结点
// 查找节点
var index = find(&n0, 2);
std.debug.print("链表中值为 2 的结点的索引 = {}\n", .{index});
std.debug.print("链表中值为 2 的节点的索引 = {}\n", .{index});
_ = try std.io.getStdIn().reader().readByte();
}

30
codes/zig/chapter_heap/my_heap.zig
View File

@@ -18,7 +18,7 @@ pub fn MaxHeap(comptime T: type) type {
self.max_heap = std.ArrayList(T).init(allocator);
// 将列表元素原封不动添加进堆
try self.max_heap.?.appendSlice(nums);
// 堆化除叶结点以外的其他所有结点
// 堆化除叶节点以外的其他所有节点
var i: usize = parent(self.size() - 1) + 1;
while (i > 0) : (i -= 1) {
try self.siftDown(i - 1);
@@ -30,17 +30,17 @@ pub fn MaxHeap(comptime T: type) type {
if (self.max_heap != null) self.max_heap.?.deinit();
}
// 获取左子结点索引
// 获取左子节点索引
fn left(i: usize) usize {
return 2 * i + 1;
}
// 获取右子结点索引
// 获取右子节点索引
fn right(i: usize) usize {
return 2 * i + 2;
}
// 获取父结点索引
// 获取父节点索引
fn parent(i: usize) usize {
// return (i - 1) / 2; // 向下整除
return @divFloor(i - 1, 2);
@@ -72,21 +72,21 @@ pub fn MaxHeap(comptime T: type) type {
// 元素入堆
pub fn push(self: *Self, val: T) !void {
// 添加结点
// 添加节点
try self.max_heap.?.append(val);
// 从底至顶堆化
try self.siftUp(self.size() - 1);
}
// 从结点 i 开始，从底至顶堆化
// 从节点 i 开始，从底至顶堆化
fn siftUp(self: *Self, i_: usize) !void {
var i = i_;
while (true) {
// 获取结点 i 的父结点
// 获取节点 i 的父节点
var p = parent(i);
// 当“越过根结点”或“结点无需修复”时，结束堆化
// 当“越过根节点”或“节点无需修复”时，结束堆化
if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;
// 交换两结点
// 交换两节点
try self.swap(i, p);
// 循环向上堆化
i = p;
@@ -97,9 +97,9 @@ pub fn MaxHeap(comptime T: type) type {
pub fn pop(self: *Self) !T {
// 判断处理
if (self.isEmpty()) unreachable;
// 交换根结点与最右叶结点（即交换首元素与尾元素）
// 交换根节点与最右叶节点（即交换首元素与尾元素）
try self.swap(0, self.size() - 1);
// 删除结点
// 删除节点
var val = self.max_heap.?.pop();
// 从顶至底堆化
try self.siftDown(0);
@@ -107,19 +107,19 @@ pub fn MaxHeap(comptime T: type) type {
return val;
}
// 从结点 i 开始，从顶至底堆化
// 从节点 i 开始，从顶至底堆化
fn siftDown(self: *Self, i_: usize) !void {
var i = i_;
while (true) {
// 判断结点 i, l, r 中值最大的结点，记为 ma
// 判断节点 i, l, r 中值最大的节点，记为 ma
var l = left(i);
var r = right(i);
var ma = i;
if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;
if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (ma == i) break;
// 交换两结点
// 交换两节点
try self.swap(i, ma);
// 循环向下堆化
i = ma;

4
codes/zig/chapter_searching/hashing_search.zig
View File

@@ -15,7 +15,7 @@ fn hashingSearchArray(comptime T: type, map: std.AutoHashMap(T, T), target: T) T
// 哈希查找（链表）
fn hashingSearchLinkedList(comptime T: type, map: std.AutoHashMap(T, *inc.ListNode(T)), target: T) ?*inc.ListNode(T) {
// 哈希表的 key: 目标结点值，value: 结点对象
// 哈希表的 key: 目标节点值，value: 节点对象
// 若哈希表中无此 key ，返回 null
if (map.getKey(target) == null) return null;
return map.get(target);
@@ -49,7 +49,7 @@ pub fn main() !void {
head = head.?.next;
}
var node = hashingSearchLinkedList(i32, map1, target);
std.debug.print("目标结点值 3 的对应结点对象为 ", .{});
std.debug.print("目标节点值 3 的对应节点对象为 ", .{});
try inc.PrintUtil.printLinkedList(i32, node);
_ = try std.io.getStdIn().reader().readByte();

4
codes/zig/chapter_searching/linear_search.zig
View File

@@ -23,7 +23,7 @@ pub fn linearSearchLinkedList(comptime T: type, node: ?*inc.ListNode(T), target:
var head = node;
// 遍历链表
while (head != null) {
// 找到目标结点，返回之
// 找到目标节点，返回之
if (head.?.val == target) return head;
head = head.?.next;
}
@@ -47,7 +47,7 @@ pub fn main() !void {
const mem_allocator = mem_arena.allocator();
var head = try inc.ListUtil.listToLinkedList(i32, mem_allocator, nums);
var node = linearSearchLinkedList(i32, head, target);
std.debug.print("目标结点值 3 的对应结点对象为 ", .{});
std.debug.print("目标节点值 3 的对应节点对象为 ", .{});
try inc.PrintUtil.printLinkedList(i32, node);
_ = try std.io.getStdIn().reader().readByte();

28
codes/zig/chapter_stack_and_queue/linkedlist_deque.zig
View File

@@ -5,14 +5,14 @@
const std = @import("std");
const inc = @import("include");
// 双向链表结点
// 双向链表节点
pub fn ListNode(comptime T: type) type {
return struct {
const Self = @This();
val: T = undefined, // 结点值
next: ?*Self = null, // 后继结点引用（指针）
prev: ?*Self = null, // 前驱结点引用（指针）
val: T = undefined, // 节点值
next: ?*Self = null, // 后继节点引用（指针）
prev: ?*Self = null, // 前驱节点引用（指针）
// Initialize a list node with specific value
pub fn init(self: *Self, x: i32) void {
@@ -28,8 +28,8 @@ pub fn LinkedListDeque(comptime T: type) type {
return struct {
const Self = @This();
front: ?*ListNode(T) = null, // 头结点 front
rear: ?*ListNode(T) = null, // 尾结点 rear
front: ?*ListNode(T) = null, // 头节点 front
rear: ?*ListNode(T) = null, // 尾节点 rear
que_size: usize = 0, // 双向队列的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
@@ -74,13 +74,13 @@ pub fn LinkedListDeque(comptime T: type) type {
// 将 node 添加至链表头部
self.front.?.prev = node;
node.next = self.front;
self.front = node; // 更新头结点
self.front = node; // 更新头节点
// 队尾入队操作
} else {
// 将 node 添加至链表尾部
self.rear.?.next = node;
node.prev = self.rear;
self.rear = node; // 更新尾结点
self.rear = node; // 更新尾节点
}
self.que_size += 1; // 更新队列长度
}
@@ -101,24 +101,24 @@ pub fn LinkedListDeque(comptime T: type) type {
var val: T = undefined;
// 队首出队操作
if (is_front) {
val = self.front.?.val; // 暂存头结点值
// 删除头结点
val = self.front.?.val; // 暂存头节点值
// 删除头节点
var fNext = self.front.?.next;
if (fNext != null) {
fNext.?.prev = null;
self.front.?.next = null;
}
self.front = fNext; // 更新头结点
self.front = fNext; // 更新头节点
// 队尾出队操作
} else {
val = self.rear.?.val; // 暂存尾结点值
// 删除尾结点
val = self.rear.?.val; // 暂存尾节点值
// 删除尾节点
var rPrev = self.rear.?.prev;
if (rPrev != null) {
rPrev.?.next = null;
self.rear.?.prev = null;
}
self.rear = rPrev; // 更新尾结点
self.rear = rPrev; // 更新尾节点
}
self.que_size -= 1; // 更新队列长度
return val;

12
codes/zig/chapter_stack_and_queue/linkedlist_queue.zig
View File

@@ -10,8 +10,8 @@ pub fn LinkedListQueue(comptime T: type) type {
return struct {
const Self = @This();
front: ?*inc.ListNode(T) = null, // 头结点 front
rear: ?*inc.ListNode(T) = null, // 尾结点 rear
front: ?*inc.ListNode(T) = null, // 头节点 front
rear: ?*inc.ListNode(T) = null, // 尾节点 rear
que_size: usize = 0, // 队列的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
@@ -51,14 +51,14 @@ pub fn LinkedListQueue(comptime T: type) type {
// 入队
pub fn push(self: *Self, num: T) !void {
// 尾结点后添加 num
// 尾节点后添加 num
var node = try self.mem_allocator.create(inc.ListNode(T));
node.init(num);
// 如果队列为空，则令头、尾结点都指向该结点
// 如果队列为空，则令头、尾节点都指向该节点
if (self.front == null) {
self.front = node;
self.rear = node;
// 如果队列不为空，则将该结点添加到尾结点后
// 如果队列不为空，则将该节点添加到尾节点后
} else {
self.rear.?.next = node;
self.rear = node;
@@ -69,7 +69,7 @@ pub fn LinkedListQueue(comptime T: type) type {
// 出队
pub fn pop(self: *Self) T {
var num = self.peek();
// 删除头结点
// 删除头节点
self.front = self.front.?.next;
self.que_size -= 1;
return num;

2
codes/zig/chapter_stack_and_queue/linkedlist_stack.zig
View File

@@ -10,7 +10,7 @@ pub fn LinkedListStack(comptime T: type) type {
return struct {
const Self = @This();
stack_top: ?*inc.ListNode(T) = null, // 将头结点作为栈顶
stack_top: ?*inc.ListNode(T) = null, // 将头节点作为栈顶
stk_size: usize = 0, // 栈的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器

92
codes/zig/chapter_tree/avl_tree.zig
View File

@@ -10,7 +10,7 @@ pub fn AVLTree(comptime T: type) type {
return struct {
const Self = @This();
root: ?*inc.TreeNode(T) = null, // 根结点
root: ?*inc.TreeNode(T) = null, // 根节点
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
@@ -28,24 +28,24 @@ pub fn AVLTree(comptime T: type) type {
self.mem_arena.?.deinit();
}
// 获取结点高度
// 获取节点高度
fn height(self: *Self, node: ?*inc.TreeNode(T)) i32 {
_ = self;
// 空结点高度为 -1 ，叶结点高度为 0
// 空节点高度为 -1 ，叶节点高度为 0
return if (node == null) -1 else node.?.height;
}
// 更新结点高度
// 更新节点高度
fn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void {
// 结点高度等于最高子树高度 + 1
// 节点高度等于最高子树高度 + 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
// 空节点平衡因子为 0
if (node == null) return 0;
// 结点平衡因子 = 左子树高度 - 右子树高度
// 节点平衡因子 = 左子树高度 - 右子树高度
return self.height(node.?.left) - self.height(node.?.right);
}
@@ -56,10 +56,10 @@ pub fn AVLTree(comptime T: type) type {
// 以 child 为原点，将 node 向右旋转
child.?.right = node;
node.?.left = grandChild;
// 更新结点高度
// 更新节点高度
self.updateHeight(node);
self.updateHeight(child);
// 返回旋转后子树的根结点
// 返回旋转后子树的根节点
return child;
}
@@ -70,16 +70,16 @@ pub fn AVLTree(comptime T: type) type {
// 以 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 的平衡因子
// 获取节点 node 的平衡因子
var balance_factor = self.balanceFactor(node);
// 左偏树
if (balance_factor > 1) {
@@ -107,13 +107,13 @@ pub fn AVLTree(comptime T: type) type {
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) {
@@ -121,32 +121,32 @@ pub fn AVLTree(comptime T: type) type {
tmp_node.init(val);
return tmp_node;
}
// 1. 查找插入位置，并插入结点
// 1. 查找插入位置，并插入节点
if (val < node.?.val) {
node.?.left = try self.insertHelper(node.?.left, val);
} else if (val > node.?.val) {
node.?.right = try self.insertHelper(node.?.right, val);
} else {
return node; // 重复结点不插入，直接返回
return node; // 重复节点不插入，直接返回
}
self.updateHeight(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. 查找结点，并删除之
// 1. 查找节点，并删除之
if (val < node.?.val) {
node.?.left = self.removeHelper(node.?.left, val);
} else if (val > node.?.val) {
@@ -154,56 +154,56 @@ pub fn AVLTree(comptime T: type) type {
} else {
if (node.?.left == null or node.?.right == null) {
var child = if (node.?.left != null) node.?.left else node.?.right;
// 子结点数量 = 0 ，直接删除 node 并返回
// 子节点数量 = 0 ，直接删除 node 并返回
if (child == null) {
return null;
// 子结点数量 = 1 ，直接删除 node
// 子节点数量 = 1 ，直接删除 node
} else {
node = child;
}
} else {
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
var temp = self.getInOrderNext(node.?.right);
node.?.right = self.removeHelper(node.?.right, temp.?.val);
node.?.val = temp.?.val;
}
}
self.updateHeight(node); // 更新结点高度
self.updateHeight(node); // 更新节点高度
// 2. 执行旋转操作，使该子树重新恢复平衡
node = self.rotate(node);
// 返回子树的根结点
// 返回子树的根节点
return node;
}
// 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况）
// 获取中序遍历中的下一个节点（仅适用于 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 的右子树中
// 目标节点在 cur 的右子树中
if (cur.?.val < val) {
cur = cur.?.right;
// 目标结点在 cur 的左子树中
// 目标节点在 cur 的左子树中
} else if (cur.?.val > val) {
cur = cur.?.left;
// 找到目标结点，跳出循环
// 找到目标节点，跳出循环
} else {
break;
}
}
// 返回目标结点
// 返回目标节点
return cur;
}
};
@@ -212,14 +212,14 @@ pub fn AVLTree(comptime T: type) type {
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});
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});
std.debug.print("\n删除节点 {} 后，AVL 树为\n", .{val});
try inc.PrintUtil.printTree(tree.root, null, false);
}
@@ -230,8 +230,8 @@ pub fn main() !void {
avl_tree.init(std.heap.page_allocator);
defer avl_tree.deinit();
// 插入结点
// 请关注插入结点后，AVL 树是如何保持平衡的
// 插入节点
// 请关注插入节点后，AVL 树是如何保持平衡的
try testInsert(i32, &avl_tree, 1);
try testInsert(i32, &avl_tree, 2);
try testInsert(i32, &avl_tree, 3);
@@ -243,18 +243,18 @@ pub fn main() !void {
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 的结点
// 删除节点
// 请关注删除节点后，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});
std.debug.print("\n查找到的节点对象为 {any}，节点值 = {}\n", .{node, node.val});
_ = try std.io.getStdIn().reader().readByte();
}

68
codes/zig/chapter_tree/binary_search_tree.zig
View File

@@ -33,7 +33,7 @@ pub fn BinarySearchTree(comptime T: type) type {
// 构建二叉搜索树
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]);
@@ -43,40 +43,40 @@ pub fn BinarySearchTree(comptime T: type) type {
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 的右子树中
// 目标节点在 cur 的右子树中
if (cur.?.val < num) {
cur = cur.?.right;
// 目标结点在 cur 的左子树中
// 目标节点在 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 的右子树中
@@ -87,7 +87,7 @@ pub fn BinarySearchTree(comptime T: type) type {
cur = cur.?.left;
}
}
// 插入结点 val
// 插入节点 val
var node = try self.mem_allocator.create(inc.TreeNode(T));
node.init(num);
if (pre.?.val < num) {
@@ -98,43 +98,43 @@ pub fn BinarySearchTree(comptime T: type) type {
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 的右子树中
// 待删除节点在 cur 的右子树中
if (cur.?.val < num) {
cur = cur.?.right;
// 待删除结点在 cur 的左子树中
// 待删除节点在 cur 的左子树中
} else {
cur = cur.?.left;
}
}
// 若无待删除结点，则直接返回
// 若无待删除节点，则直接返回
if (cur == null) return null;
// 子结点数量 = 0 or 1
// 子节点数量 = 0 or 1
if (cur.?.left == null or cur.?.right == null) {
// 当子结点数量 = 0 / 1 时， child = null / 该子结点
// 当子节点数量 = 0 / 1 时， child = null / 该子节点
var child = if (cur.?.left != null) cur.?.left else cur.?.right;
// 删除结点 cur
// 删除节点 cur
if (pre.?.left == cur) {
pre.?.left = child;
} else {
pre.?.right = child;
}
// 子结点数量 = 2
// 子节点数量 = 2
} else {
// 获取中序遍历中 cur 的下一个结点
// 获取中序遍历中 cur 的下一个节点
var nex = self.getInOrderNext(cur.?.right);
var tmp = nex.?.val;
// 递归删除结点 nex
// 递归删除节点 nex
_ = self.remove(nex.?.val);
// 将 nex 的值复制给 cur
cur.?.val = tmp;
@@ -142,12 +142,12 @@ pub fn BinarySearchTree(comptime T: type) type {
return cur;
}
// 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况）
// 获取中序遍历中的下一个节点（仅适用于 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;
}
@@ -166,24 +166,24 @@ pub fn main() !void {
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});
std.debug.print("\n查找到的节点对象为 {any}，节点值 = {}\n", .{node, node.?.val});
// 插入结点
// 插入节点
node = try bst.insert(16);
std.debug.print("\n插入结点 16 后，二叉树为\n", .{});
std.debug.print("\n插入节点 16 后，二叉树为\n", .{});
try inc.PrintUtil.printTree(bst.getRoot(), null, false);
// 删除结点
// 删除节点
_ = bst.remove(1);
std.debug.print("\n删除结点 1 后，二叉树为\n", .{});
std.debug.print("\n删除节点 1 后，二叉树为\n", .{});
try inc.PrintUtil.printTree(bst.getRoot(), null, false);
_ = bst.remove(2);
std.debug.print("\n删除结点 2 后，二叉树为\n", .{});
std.debug.print("\n删除节点 2 后，二叉树为\n", .{});
try inc.PrintUtil.printTree(bst.getRoot(), null, false);
_ = bst.remove(4);
std.debug.print("\n删除结点 4 后，二叉树为\n", .{});
std.debug.print("\n删除节点 4 后，二叉树为\n", .{});
try inc.PrintUtil.printTree(bst.getRoot(), null, false);
_ = try std.io.getStdIn().reader().readByte();

12
codes/zig/chapter_tree/binary_tree.zig
View File

@@ -8,7 +8,7 @@ const inc = @import("include");
// Driver Code
pub fn main() !void {
// 初始化二叉树
// 初始化结点
// 初始化节点
var n1 = inc.TreeNode(i32){ .val = 1 };
var n2 = inc.TreeNode(i32){ .val = 2 };
var n3 = inc.TreeNode(i32){ .val = 3 };
@@ -22,16 +22,16 @@ pub fn main() !void {
std.debug.print("初始化二叉树\n", .{});
try inc.PrintUtil.printTree(&n1, null, false);
// 插入与删除结点
// 插入与删除节点
var p = inc.TreeNode(i32){ .val = 0 };
// 在 n1 -> n2 中间插入结点 P
// 在 n1 -> n2 中间插入节点 P
n1.left = &p;
p.left = &n2;
std.debug.print("插入结点 P 后\n", .{});
std.debug.print("插入节点 P 后\n", .{});
try inc.PrintUtil.printTree(&n1, null, false);
// 删除结点
// 删除节点
n1.left = &n2;
std.debug.print("删除结点 P 后\n", .{});
std.debug.print("删除节点 P 后\n", .{});
try inc.PrintUtil.printTree(&n1, null, false);
_ = try std.io.getStdIn().reader().readByte();

10
codes/zig/chapter_tree/binary_tree_bfs.zig
View File

@@ -7,7 +7,7 @@ const inc = @import("include");
// 层序遍历
fn levelOrder(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);
@@ -18,16 +18,16 @@ fn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.Tre
while (queue.len > 0) {
var queue_node = queue.popFirst().?; // 队列出队
var node = queue_node.data;
try list.append(node.val); // 保存结点值
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); // 左子结点入队
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); // 右子结点入队
queue.append(tmp_node); // 右子节点入队
}
}
return list;
@@ -50,7 +50,7 @@ pub fn main() !void {
// 层序遍历
var list = try levelOrder(i32, mem_allocator, root.?);
defer list.deinit();
std.debug.print("\n层序遍历的结点打印序列 = ", .{});
std.debug.print("\n层序遍历的节点打印序列 = ", .{});
inc.PrintUtil.printList(i32, list);
_ = try std.io.getStdIn().reader().readByte();

12
codes/zig/chapter_tree/binary_tree_dfs.zig
View File

@@ -10,7 +10,7 @@ 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);
@@ -19,7 +19,7 @@ fn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
// 中序遍历
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);
@@ -28,7 +28,7 @@ fn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
// 后序遍历
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);
@@ -51,19 +51,19 @@ pub fn main() !void {
// 前序遍历
list.clearRetainingCapacity();
try preOrder(i32, root);
std.debug.print("\n前序遍历的结点打印序列 = ", .{});
std.debug.print("\n前序遍历的节点打印序列 = ", .{});
inc.PrintUtil.printList(i32, list);
// 中序遍历
list.clearRetainingCapacity();
try inOrder(i32, root);
std.debug.print("\n中序遍历的结点打印序列 = ", .{});
std.debug.print("\n中序遍历的节点打印序列 = ", .{});
inc.PrintUtil.printList(i32, list);
// 后序遍历
list.clearRetainingCapacity();
try postOrder(i32, root);
std.debug.print("\n后续遍历的结点打印序列 = ", .{});
std.debug.print("\n后续遍历的节点打印序列 = ", .{});
inc.PrintUtil.printList(i32, list);
_ = try std.io.getStdIn().reader().readByte();

8
codes/zig/include/TreeNode.zig
View File

@@ -9,10 +9,10 @@ pub fn TreeNode(comptime T: type) type {
return struct {
const Self = @This();
val: T = undefined, // 结点值
height: i32 = 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 {