CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-10 22:30:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-02-09 22:55:29 +08:00
parent 3dcf65c61b
commit 7d86e2dd11
18 changed files with 1029 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
chapter_array_and_linkedlist/array.md
View File

@@ -230,7 +230,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```zig title="array.zig"
// 随机返回一个数组元素
pub fn randomAccess(nums: []i32) i32 {
fn randomAccess(nums: []i32) i32 {
// 在区间 [0, nums.len) 中随机抽取一个整数
var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
// 获取并返回随机元素
@@ -389,7 +389,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```zig title="array.zig"
// 扩展数组长度
pub fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
// 初始化一个扩展长度后的数组
var res = try mem_allocator.alloc(i32, nums.len + enlarge);
std.mem.set(i32, res, 0);
@@ -597,7 +597,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```zig title="array.zig"
// 在数组的索引 index 处插入元素 num
pub fn insert(nums: []i32, num: i32, index: usize) void {
fn insert(nums: []i32, num: i32, index: usize) void {
// 把索引 index 以及之后的所有元素向后移动一位
var i = nums.len - 1;
while (i > index) : (i -= 1) {
@@ -608,7 +608,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
// 删除索引 index 处元素
pub fn remove(nums: []i32, index: usize) void {
fn remove(nums: []i32, index: usize) void {
// 把索引 index 之后的所有元素向前移动一位
var i = index;
while (i < nums.len - 1) : (i += 1) {
@@ -764,7 +764,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```zig title="array.zig"
// 遍历数组
pub fn traverse(nums: []i32) void {
fn traverse(nums: []i32) void {
var count: i32 = 0;
// 通过索引遍历数组
var i: i32 = 0;
@@ -899,7 +899,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```zig title="array.zig"
// 在数组中查找指定元素
pub fn find(nums: []i32, target: i32) i32 {
fn find(nums: []i32, target: i32) i32 {
for (nums) |num, i| {
if (num == target) return @intCast(i32, i);
}

8
chapter_array_and_linkedlist/linked_list.md
View File

@@ -506,14 +506,14 @@ comments: true
```zig title="linked_list.zig"
// 在链表的结点 n0 之后插入结点 P
pub fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
n0.?.next = P;
P.?.next = n1;
}
// 删除链表的结点 n0 之后的首个结点
pub fn remove(n0: ?*inc.ListNode(i32)) void {
fn remove(n0: ?*inc.ListNode(i32)) void {
if (n0.?.next == null) return;
// n0 -> P -> n1
var P = n0.?.next;
@@ -653,7 +653,7 @@ comments: true
```zig title="linked_list.zig"
// 访问链表中索引为 index 的结点
pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
var i: i32 = 0;
while (i < index) : (i += 1) {
@@ -813,7 +813,7 @@ comments: true
```zig title="linked_list.zig"
// 在链表中查找值为 target 的首个结点
pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
var index: i32 = 0;
while (head != null) {

2
chapter_array_and_linkedlist/list.md
View File

@@ -1552,7 +1552,7 @@ comments: true
```zig title="my_list.zig"
// 列表类简易实现
pub fn MyList(comptime T: type) type {
fn MyList(comptime T: type) type {
return struct {
const Self = @This();

58
chapter_computational_complexity/space_time_tradeoff.md
View File

@@ -177,23 +177,22 @@ comments: true
=== "Zig"
```zig title="leetcode_two_sum.zig"
const SolutionBruteForce = struct {
pub fn twoSum(self: *SolutionBruteForce, nums: []i32, target: i32) [2]i32 {
_ = self;
var size: usize = nums.len;
var i: usize = 0;
// 两层循环，时间复杂度 O(n^2)
while (i < size - 1) : (i += 1) {
var j = i + 1;
while (j < size) : (j += 1) {
if (nums[i] + nums[j] == target) {
return [_]i32{@intCast(i32, i), @intCast(i32, j)};
}
// 方法一：暴力枚举
fn twoSumBruteForce(nums: []i32, target: i32) [2]i32 {
_ = self;
var size: usize = nums.len;
var i: usize = 0;
// 两层循环，时间复杂度 O(n^2)
while (i < size - 1) : (i += 1) {
var j = i + 1;
while (j < size) : (j += 1) {
if (nums[i] + nums[j] == target) {
return [_]i32{@intCast(i32, i), @intCast(i32, j)};
}
}
return undefined;
}
};
return undefined;
}
```
### 方法二：辅助哈希表
@@ -361,22 +360,21 @@ comments: true
=== "Zig"
```zig title="leetcode_two_sum.zig"
const SolutionHashMap = struct {
pub fn twoSum(self: *SolutionHashMap, nums: []i32, target: i32) ![2]i32 {
_ = self;
var size: usize = nums.len;
// 辅助哈希表，空间复杂度 O(n)
var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
defer dic.deinit();
var i: usize = 0;
// 单层循环，时间复杂度 O(n)
while (i < size) : (i += 1) {
if (dic.contains(target - nums[i])) {
return [_]i32{dic.get(target - nums[i]).?, @intCast(i32, i)};
}
try dic.put(nums[i], @intCast(i32, i));
// 方法二：辅助哈希表
fn twoSumHashTable(nums: []i32, target: i32) ![2]i32 {
_ = self;
var size: usize = nums.len;
// 辅助哈希表，空间复杂度 O(n)
var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
defer dic.deinit();
var i: usize = 0;
// 单层循环，时间复杂度 O(n)
while (i < size) : (i += 1) {
if (dic.contains(target - nums[i])) {
return [_]i32{dic.get(target - nums[i]).?, @intCast(i32, i)};
}
return undefined;
try dic.put(nums[i], @intCast(i32, i));
}
};
return undefined;
}
```

17
chapter_computational_complexity/time_complexity.md
View File

@@ -1363,7 +1363,7 @@ $$
}
}
return count;
}
}
```
![time_complexity_constant_linear_quadratic](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
@@ -1788,7 +1788,7 @@ $$
```zig title="time_complexity.zig"
// 指数阶（循环实现）
fn exponential(n: i32) i32{
fn exponential(n: i32) i32 {
var count: i32 = 0;
var bas: i32 = 1;
var i: i32 = 0;
@@ -1802,7 +1802,7 @@ $$
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count;
}
}
```
![time_complexity_exponential](time_complexity.assets/time_complexity_exponential.png)
@@ -1909,7 +1909,7 @@ $$
```zig title="time_complexity.zig"
// 指数阶（递归实现）
fn expRecur(n: i32) i32{
fn expRecur(n: i32) i32 {
if (n == 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
@@ -2054,8 +2054,7 @@ $$
```zig title="time_complexity.zig"
// 对数阶（循环实现）
fn logarithmic(n: f32) i32
{
fn logarithmic(n: f32) i32 {
var count: i32 = 0;
var n_var = n;
while (n_var > 1)
@@ -2171,8 +2170,7 @@ $$
```zig title="time_complexity.zig"
// 对数阶（递归实现）
fn logRecur(n: f32) i32
{
fn logRecur(n: f32) i32 {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
}
@@ -2324,8 +2322,7 @@ $$
```zig title="time_complexity.zig"
// 线性对数阶
fn linearLogRecur(n: f32) i32
{
fn linearLogRecur(n: f32) i32 {
if (n <= 1) return 1;
var count: i32 = linearLogRecur(n / 2) +
linearLogRecur(n / 2);

103
chapter_hashing/hash_map.md
View File

@@ -1158,7 +1158,110 @@ $$
=== "Zig"
```zig title="array_hash_map.zig"
// 键值对 int->String
const Entry = struct {
key: usize = undefined,
val: []const u8 = undefined,
pub fn init(key: usize, val: []const u8) Entry {
return Entry {
.key = key,
.val = val,
};
}
};
// 基于数组简易实现的哈希表
fn ArrayHashMap(comptime T: type) type {
return struct {
bucket: ?std.ArrayList(?T) = null,
mem_allocator: std.mem.Allocator = undefined,
const Self = @This();
// 构造函数
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
self.mem_allocator = allocator;
// 初始化一个长度为 100 的桶（数组）
self.bucket = std.ArrayList(?T).init(self.mem_allocator);
var i: i32 = 0;
while (i < 100) : (i += 1) {
try self.bucket.?.append(null);
}
}
// 析构函数
pub fn deinit(self: *Self) void {
if (self.bucket != null) self.bucket.?.deinit();
}
// 哈希函数
fn hashFunc(key: usize) usize {
var index = key % 100;
return index;
}
// 查询操作
pub fn get(self: *Self, key: usize) []const u8 {
var index = hashFunc(key);
var pair = self.bucket.?.items[index];
return pair.?.val;
}
// 添加操作
pub fn put(self: *Self, key: usize, val: []const u8) !void {
var pair = Entry.init(key, val);
var index = hashFunc(key);
self.bucket.?.items[index] = pair;
}
// 删除操作
pub fn remove(self: *Self, key: usize) !void {
var index = hashFunc(key);
// 置为 null ，代表删除
self.bucket.?.items[index] = null;
}
// 获取所有键值对
pub fn entrySet(self: *Self) !*std.ArrayList(T) {
var entry_set = std.ArrayList(T).init(self.mem_allocator);
for (self.bucket.?.items) |item| {
if (item == null) continue;
try entry_set.append(item.?);
}
return &entry_set;
}
// 获取所有键
pub fn keySet(self: *Self) !*std.ArrayList(usize) {
var key_set = std.ArrayList(usize).init(self.mem_allocator);
for (self.bucket.?.items) |item| {
if (item == null) continue;
try key_set.append(item.?.key);
}
return &key_set;
}
// 获取所有值
pub fn valueSet(self: *Self) !*std.ArrayList([]const u8) {
var value_set = std.ArrayList([]const u8).init(self.mem_allocator);
for (self.bucket.?.items) |item| {
if (item == null) continue;
try value_set.append(item.?.val);
}
return &value_set;
}
// 打印哈希表
pub fn print(self: *Self) !void {
var entry_set = try self.entrySet();
defer entry_set.deinit();
for (entry_set.items) |item| {
std.debug.print("{} -> {s}\n", .{item.key, item.val});
}
}
};
}
```
## 6.1.4. 哈希冲突

84
chapter_heap/heap.md
View File

@@ -397,7 +397,21 @@ comments: true
=== "Zig"
```zig title="my_heap.zig"
// 获取左子结点索引
fn left(i: usize) usize {
return 2 * i + 1;
}
// 获取右子结点索引
fn right(i: usize) usize {
return 2 * i + 2;
}
// 获取父结点索引
fn parent(i: usize) usize {
// return (i - 1) / 2; // 向下整除
return @divFloor(i - 1, 2);
}
```
### 访问堆顶元素
@@ -479,7 +493,10 @@ comments: true
=== "Zig"
```zig title="my_heap.zig"
// 访问堆顶元素
fn peek(self: *Self) T {
return self.maxHeap.?.items[0];
}
```
### 元素入堆
@@ -694,7 +711,28 @@ comments: true
=== "Zig"
```zig title="my_heap.zig"
// 元素入堆
fn push(self: *Self, val: T) !void {
// 添加结点
try self.maxHeap.?.append(val);
// 从底至顶堆化
try self.siftUp(self.size() - 1);
}
// 从结点 i 开始，从底至顶堆化
fn siftUp(self: *Self, i_: usize) !void {
var i = i_;
while (true) {
// 获取结点 i 的父结点
var p = parent(i);
// 当“越过根结点”或“结点无需修复”时，结束堆化
if (p < 0 or self.maxHeap.?.items[i] <= self.maxHeap.?.items[p]) break;
// 交换两结点
try self.swap(i, p);
// 循环向上堆化
i = p;
}
}
```
### 堆顶元素出堆
@@ -998,7 +1036,38 @@ comments: true
=== "Zig"
```zig title="my_heap.zig"
// 元素出堆
fn poll(self: *Self) !T {
// 判断处理
if (self.isEmpty()) unreachable;
// 交换根结点与最右叶结点（即交换首元素与尾元素）
try self.swap(0, self.size() - 1);
// 删除结点
var val = self.maxHeap.?.pop();
// 从顶至底堆化
try self.siftDown(0);
// 返回堆顶元素
return val;
}
// 从结点 i 开始，从顶至底堆化
fn siftDown(self: *Self, i_: usize) !void {
var i = i_;
while (true) {
// 判断结点 i, l, r 中值最大的结点，记为 ma
var l = left(i);
var r = right(i);
var ma = i;
if (l < self.size() and self.maxHeap.?.items[l] > self.maxHeap.?.items[ma]) ma = l;
if (r < self.size() and self.maxHeap.?.items[r] > self.maxHeap.?.items[ma]) ma = r;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (ma == i) break;
// 交换两结点
try self.swap(i, ma);
// 循环向下堆化
i = ma;
}
}
```
### 输入数据并建堆 *
@@ -1113,7 +1182,18 @@ comments: true
=== "Zig"
```zig title="my_heap.zig"
// 构造函数，根据输入列表建堆
fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
if (self.maxHeap != null) return;
self.maxHeap = std.ArrayList(T).init(allocator);
// 将列表元素原封不动添加进堆
try self.maxHeap.?.appendSlice(nums);
// 堆化除叶结点以外的其他所有结点
var i: usize = parent(self.size() - 1) + 1;
while (i > 0) : (i -= 1) {
try self.siftDown(i - 1);
}
}
```
那么，第二种建堆方法的时间复杂度时多少呢？我们来做一下简单推算。

40
chapter_searching/binary_search.md
View File

@@ -237,7 +237,25 @@ $$
=== "Zig"
```zig title="binary_search.zig"
// 二分查找（双闭区间）
fn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
var i: usize = 0;
var j: usize = nums.items.len - 1;
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
while (i <= j) {
var m = (i + j) / 2; // 计算中点索引 m
if (nums.items[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中
i = m + 1;
} else if (nums.items[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
j = m - 1;
} else { // 找到目标元素，返回其索引
return @intCast(T, m);
}
}
// 未找到目标元素，返回 -1
return -1;
}
```
### “左闭右开”实现
@@ -431,7 +449,25 @@ $$
=== "Zig"
```zig title="binary_search.zig"
// 二分查找（左闭右开）
fn binarySearch1(comptime T: type, nums: std.ArrayList(T), target: T) T {
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
var i: usize = 0;
var j: usize = nums.items.len;
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
while (i <= j) {
var m = (i + j) / 2; // 计算中点索引 m
if (nums.items[m] < target) { // 此情况说明 target 在区间 [m+1, j) 中
i = m + 1;
} else if (nums.items[m] > target) { // 此情况说明 target 在区间 [i, m) 中
j = m;
} else { // 找到目标元素，返回其索引
return @intCast(T, m);
}
}
// 未找到目标元素，返回 -1
return -1;
}
```
### 两种表示对比

16
chapter_searching/hashing_search.md
View File

@@ -119,7 +119,13 @@ comments: true
=== "Zig"
```zig title="hashing_search.zig"
// 哈希查找（数组）
fn hashingSearchArray(comptime T: type, map: std.AutoHashMap(T, T), target: T) T {
// 哈希表的 key: 目标元素，value: 索引
// 若哈希表中无此 key ，返回 -1
if (map.getKey(target) == null) return -1;
return map.get(target).?;
}
```
再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
@@ -230,7 +236,13 @@ comments: true
=== "Zig"
```zig title="hashing_search.zig"
// 哈希查找（链表）
fn hashingSearchLinkedList(comptime T: type, map: std.AutoHashMap(T, *inc.ListNode(T)), target: T) ?*inc.ListNode(T) {
// 哈希表的 key: 目标结点值，value: 结点对象
// 若哈希表中无此 key ，返回 null
if (map.getKey(target) == null) return null;
return map.get(target);
}
```
## 10.3.2. 复杂度分析

25
chapter_searching/linear_search.md
View File

@@ -151,7 +151,18 @@ comments: true
=== "Zig"
```zig title="linear_search.zig"
// 线性查找（数组）
fn linearSearchArray(comptime T: type, nums: std.ArrayList(T), target: T) T {
// 遍历数组
for (nums.items) |num, i| {
// 找到目标元素， 返回其索引
if (num == target) {
return @intCast(T, i);
}
}
// 未找到目标元素，返回 -1
return -1;
}
```
再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
@@ -304,7 +315,17 @@ comments: true
=== "Zig"
```zig title="linear_search.zig"
// 线性查找（链表）
fn linearSearchLinkedList(comptime T: type, node: ?*inc.ListNode(T), target: T) ?*inc.ListNode(T) {
var head = node;
// 遍历链表
while (head != null) {
// 找到目标结点，返回之
if (head.?.val == target) return head;
head = head.?.next;
}
return null;
}
```
## 10.1.2. 复杂度分析

39
chapter_sorting/bubble_sort.md
View File

@@ -228,7 +228,23 @@ comments: true
=== "Zig"
```zig title="bubble_sort.zig"
// 冒泡排序
fn bubbleSort(nums: []i32) void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
var i: usize = nums.len - 1;
while (i > 0) : (i -= 1) {
var j: usize = 0;
// 内循环：冒泡操作
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
var tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
```
## 11.2.2. 算法特性
@@ -461,5 +477,24 @@ comments: true
=== "Zig"
```zig title="bubble_sort.zig"
// 冒泡排序（标志优化）
fn bubbleSortWithFlag(nums: []i32) void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
var i: usize = nums.len - 1;
while (i > 0) : (i -= 1) {
var flag = false; // 初始化标志位
var j: usize = 0;
// 内循环：冒泡操作
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
var tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true;
}
}
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
}
}
```

15
chapter_sorting/insertion_sort.md
View File

@@ -197,7 +197,20 @@ comments: true
=== "Zig"
```zig title="insertion_sort.zig"
// 插入排序
fn insertionSort(nums: []i32) void {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
var i: usize = 1;
while (i < nums.len) : (i += 1) {
var base = nums[i];
var j: usize = i;
// 内循环：将 base 插入到左边的正确位置
while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
nums[j] = nums[j - 1]; // 1. 将 nums[j] 向右移动一位
}
nums[j] = base; // 2. 将 base 赋值到正确位置
}
}
```
## 11.3.2. 算法特性

78
chapter_sorting/quick_sort.md
View File

@@ -262,7 +262,26 @@ comments: true
=== "Zig"
```zig title="quick_sort.zig"
// 元素交换
fn swap(nums: []i32, i: usize, j: usize) void {
var tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
// 哨兵划分
fn partition(nums: []i32, left: usize, right: usize) usize {
// 以 nums[left] 作为基准数
var i = left;
var j = right;
while (i < j) {
while (i < j and nums[j] >= nums[left]) j -= 1; // 从右向左找首个小于基准数的元素
while (i < j and nums[i] <= nums[left]) i += 1; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
```
!!! note "快速排序的分治思想"
@@ -420,7 +439,16 @@ comments: true
=== "Zig"
```zig title="quick_sort.zig"
// 快速排序
fn quickSort(nums: []i32, left: usize, right: usize) void {
// 子数组长度为 1 时终止递归
if (left >= right) return;
// 哨兵划分
var pivot = partition(nums, left, right);
// 递归左子数组、右子数组
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
```
## 11.4.2. 算法特性
@@ -734,7 +762,36 @@ comments: true
=== "Zig"
```zig title="quick_sort.zig"
// 选取三个元素的中位数
fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {
// 使用了异或操作来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if ((nums[left] < nums[mid]) != (nums[left] < nums[right])) {
return left;
} else if ((nums[mid] < nums[left]) != (nums[mid] < nums[right])) {
return mid;
} else {
return right;
}
}
// 哨兵划分（三数取中值）
fn partition(nums: []i32, left: usize, right: usize) usize {
// 选取三个候选元素的中位数
var med = medianThree(nums, left, (left + right) / 2, right);
// 将中位数交换至数组最左端
swap(nums, left, med);
// 以 nums[left] 作为基准数
var i = left;
var j = right;
while (i < j) {
while (i < j and nums[j] >= nums[left]) j -= 1; // 从右向左找首个小于基准数的元素
while (i < j and nums[i] <= nums[left]) i += 1; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
```
## 11.4.5. 尾递归优化
@@ -924,5 +981,22 @@ comments: true
=== "Zig"
```zig title="quick_sort.zig"
// 快速排序（尾递归优化）
fn quickSort(nums: []i32, left_: usize, right_: usize) void {
var left = left_;
var right = right_;
// 子数组长度为 1 时终止递归
while (left < right) {
// 哨兵划分操作
var pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
}
}
}
```

169
chapter_stack_and_queue/queue.md
View File

@@ -842,7 +842,90 @@ comments: true
=== "Zig"
```zig title="linkedlist_queue.zig"
// 基于链表实现的队列
fn LinkedListQueue(comptime T: type) type {
return struct {
const Self = @This();
front: ?*inc.ListNode(T) = null, // 头结点 front
rear: ?*inc.ListNode(T) = null, // 尾结点 rear
queSize: usize = 0, // 队列的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
// 构造函数（分配内存+初始化队列）
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
if (self.mem_arena == null) {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.front = null;
self.rear = null;
self.queSize = 0;
}
// 析构函数（释放内存）
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
}
// 获取队列的长度
pub fn size(self: *Self) usize {
return self.queSize;
}
// 判断队列是否为空
pub fn isEmpty(self: *Self) bool {
return self.size() == 0;
}
// 访问队首元素
pub fn peek(self: *Self) T {
if (self.size() == 0) @panic("队列为空");
return self.front.?.val;
}
// 入队
pub fn push(self: *Self, num: T) !void {
// 尾结点后添加 num
var node = try self.mem_allocator.create(inc.ListNode(T));
node.init(num);
// 如果队列为空，则令头、尾结点都指向该结点
if (self.front == null) {
self.front = node;
self.rear = node;
// 如果队列不为空，则将该结点添加到尾结点后
} else {
self.rear.?.next = node;
self.rear = node;
}
self.queSize += 1;
}
// 出队
pub fn poll(self: *Self) T {
var num = self.peek();
// 删除头结点
self.front = self.front.?.next;
self.queSize -= 1;
return num;
}
// 将链表转换为数组
pub fn toArray(self: *Self) ![]T {
var node = self.front;
var res = try self.mem_allocator.alloc(T, self.size());
std.mem.set(T, res, @as(T, 0));
var i: usize = 0;
while (i < res.len) : (i += 1) {
res[i] = node.?.val;
node = node.?.next;
}
return res;
}
};
}
```
### 基于数组的实现
@@ -1445,7 +1528,93 @@ comments: true
=== "Zig"
```zig title="array_queue.zig"
// 基于环形数组实现的队列
fn ArrayQueue(comptime T: type) type {
return struct {
const Self = @This();
nums: []T = undefined, // 用于存储队列元素的数组
cap: usize = 0, // 队列容量
front: usize = 0, // 队首指针，指向队首元素
queSize: usize = 0, // 尾指针，指向队尾 + 1
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
// 构造函数（分配内存+初始化数组）
pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {
if (self.mem_arena == null) {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.cap = cap;
self.nums = try self.mem_allocator.alloc(T, self.cap);
std.mem.set(T, self.nums, @as(T, 0));
}
// 析构函数（释放内存）
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
}
// 获取队列的容量
pub fn capacity(self: *Self) usize {
return self.cap;
}
// 获取队列的长度
pub fn size(self: *Self) usize {
return self.queSize;
}
// 判断队列是否为空
pub fn isEmpty(self: *Self) bool {
return self.queSize == 0;
}
// 入队
pub fn push(self: *Self, num: T) !void {
if (self.size() == self.capacity()) {
std.debug.print("队列已满\n", .{});
return;
}
// 计算尾指针，指向队尾索引 + 1
// 通过取余操作，实现 rear 越过数组尾部后回到头部
var rear = (self.front + self.queSize) % self.capacity();
// 尾结点后添加 num
self.nums[rear] = num;
self.queSize += 1;
}
// 出队
pub fn poll(self: *Self) T {
var num = self.peek();
// 队首指针向后移动一位，若越过尾部则返回到数组头部
self.front = (self.front + 1) % self.capacity();
self.queSize -= 1;
return num;
}
// 访问队首元素
pub fn peek(self: *Self) T {
if (self.isEmpty()) @panic("队列为空");
return self.nums[self.front];
}
// 返回数组
pub fn toArray(self: *Self) ![]T {
// 仅转换有效长度范围内的列表元素
var res = try self.mem_allocator.alloc(T, self.size());
std.mem.set(T, res, @as(T, 0));
var i: usize = 0;
var j: usize = self.front;
while (i < self.size()) : ({ i += 1; j += 1; }) {
res[i] = self.nums[j % self.capacity()];
}
return res;
}
};
}
```
以上代码仍存在局限性，即长度不可变。然而，我们可以通过将数组替换为列表（即动态数组）来引入扩容机制，有兴趣的同学可以尝试实现。

124
chapter_stack_and_queue/stack.md
View File

@@ -771,7 +771,79 @@ comments: true
=== "Zig"
```zig title="linkedlist_stack.zig"
// 基于链表实现的栈
fn LinkedListStack(comptime T: type) type {
return struct {
const Self = @This();
stackTop: ?*inc.ListNode(T) = null, // 将头结点作为栈顶
stkSize: usize = 0, // 栈的长度
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
// 构造函数（分配内存+初始化栈）
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
if (self.mem_arena == null) {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.stackTop = null;
self.stkSize = 0;
}
// 析构函数（释放内存）
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
}
// 获取栈的长度
pub fn size(self: *Self) usize {
return self.stkSize;
}
// 判断栈是否为空
pub fn isEmpty(self: *Self) bool {
return self.size() == 0;
}
// 访问栈顶元素
pub fn top(self: *Self) T {
if (self.size() == 0) @panic("栈为空");
return self.stackTop.?.val;
}
// 入栈
pub fn push(self: *Self, num: T) !void {
var node = try self.mem_allocator.create(inc.ListNode(T));
node.init(num);
node.next = self.stackTop;
self.stackTop = node;
self.stkSize += 1;
}
// 出栈
pub fn pop(self: *Self) T {
var num = self.top();
self.stackTop = self.stackTop.?.next;
self.stkSize -= 1;
return num;
}
// 将栈转换为数组
pub fn toArray(self: *Self) ![]T {
var node = self.stackTop;
var res = try self.mem_allocator.alloc(T, self.size());
std.mem.set(T, res, @as(T, 0));
var i: usize = 0;
while (i < res.len) : (i += 1) {
res[res.len - i - 1] = node.?.val;
node = node.?.next;
}
return res;
}
};
}
```
### 基于数组的实现
@@ -1178,7 +1250,59 @@ comments: true
=== "Zig"
```zig title="array_stack.zig"
// 基于数组实现的栈
fn ArrayStack(comptime T: type) type {
return struct {
const Self = @This();
stack: ?std.ArrayList(T) = null,
// 构造函数（分配内存+初始化栈）
pub fn init(self: *Self, allocator: std.mem.Allocator) void {
if (self.stack == null) {
self.stack = std.ArrayList(T).init(allocator);
}
}
// 析构函数（释放内存）
pub fn deinit(self: *Self) void {
if (self.stack == null) return;
self.stack.?.deinit();
}
// 获取栈的长度
pub fn size(self: *Self) usize {
return self.stack.?.items.len;
}
// 判断栈是否为空
pub fn isEmpty(self: *Self) bool {
return self.size() == 0;
}
// 访问栈顶元素
pub fn peek(self: *Self) T {
if (self.isEmpty()) @panic("栈为空");
return self.stack.?.items[self.size() - 1];
}
// 入栈
pub fn push(self: *Self, num: T) !void {
try self.stack.?.append(num);
}
// 出栈
pub fn pop(self: *Self) T {
var num = self.stack.?.pop();
return num;
}
// 返回 ArrayList
pub fn toList(self: *Self) std.ArrayList(T) {
return self.stack.?;
}
};
}
```
## 5.1.3. 两种实现对比

153
chapter_tree/avl_tree.md
View File

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

104
chapter_tree/binary_search_tree.md
View File

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

53
chapter_tree/binary_tree_traversal.md
View File

@@ -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