feat: iteration & recursion in Zig (#804)

* iteration & recursion in Zig

* missing part in time_complexity.md (zig)

* build.zig sync

* Update recursion.zig

* Update iteration.zig

---------

Co-authored-by: Yudong Jin <krahets@163.com>

codes/zig/build.zig

@@ -24,6 +24,14 @@ pub fn build(b: *std.Build) void {
         // Run Command: zig build run_space_complexity -Doptimize=ReleaseSafe
         .{ .name = "space_complexity", .path = "chapter_computational_complexity/space_complexity.zig" },
 
+        // Source File: "chapter_computational_complexity/iteration.zig"
+        // Run Command: zig build run_iteration -Doptimize=ReleaseFast
+        .{ .name = "iteration", .path = "chapter_computational_complexity/iteration.zig" },
+
+        // Source File: "chapter_computational_complexity/recursion.zig"
+        // Run Command: zig build run_recursion -Doptimize=ReleaseFast
+        .{ .name = "recursion", .path = "chapter_computational_complexity/recursion.zig" },
+
         // Source File: "chapter_array_and_linkedlist/array.zig"
         // Run Command: zig build run_array -Doptimize=ReleaseSafe
         .{ .name = "array", .path = "chapter_array_and_linkedlist/array.zig" },

codes/zig/chapter_computational_complexity/iteration.zig

@@ -0,0 +1,77 @@
+// File: iteration.zig
+// Created Time: 2023-09-27
+// Author: QiLOL (pikaqqpika@gmail.com)
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+// for 循环
+fn forLoop(n: usize) i32 {
+    var res: i32 = 0;
+    // 循环求和 1, 2, ..., n-1, n
+    for (1..n+1) |i| {
+        res = res + @as(i32, @intCast(i));
+    }
+    return res;
+} 
+
+// while 循环
+fn whileLoop(n: i32) i32 {
+    var res: i32 = 0;
+    var i: i32 = 1; // 初始化条件变量
+    // 循环求和 1, 2, ..., n-1, n
+    while (i <= n) {
+        res += @intCast(i);
+        i += 1;
+    }
+    return res;
+}
+
+//  while 循环（两次更新）
+fn whileLoopII(n: i32) i32 {
+    var res: i32 = 0;
+    var i: i32 = 1; // 初始化条件变量
+    // 循环求和 1, 4, ...
+    while (i <= n) {
+        res += @intCast(i);
+        // 更新条件变量
+        i += 1;
+        i *= 2;
+    }
+    return res;
+}
+
+// 双层 for 循环
+fn nestedForLoop(allocator: Allocator, n: usize) ![]const u8 {
+    var res = std.ArrayList(u8).init(allocator);
+    defer res.deinit();
+    var buffer: [20]u8 = undefined;
+    // 循环 i = 1, 2, ..., n-1, n
+    for (1..n+1) |i| {
+        // 循环 j = 1, 2, ..., n-1, n
+        for (1..n+1) |j| {
+            var _str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{i, j});
+            try res.appendSlice(_str);
+        }
+    }
+    return res.toOwnedSlice();
+}
+
+// Driver Code
+pub fn main() !void {
+    const n: i32 = 5;
+    var res: i32 = 0;
+
+    res = forLoop(n);
+    std.debug.print("\nfor 循环的求和结果 res = {}\n", .{res});
+
+    res = whileLoop(n);
+    std.debug.print("\nwhile 循环的求和结果 res = {}\n", .{res});
+
+    res = whileLoopII(n);
+    std.debug.print("\nwhile 循环（两次更新）求和结果 res = {}\n", .{res});
+
+    const allocator = std.heap.page_allocator;
+    const resStr = try nestedForLoop(allocator, n);
+    std.debug.print("\n双层 for 循环的遍历结果 {s}\n", .{resStr});
+}

codes/zig/chapter_computational_complexity/recursion.zig

@@ -0,0 +1,78 @@
+// File: recursion.zig
+// Created Time: 2023-09-27
+// Author: QiLOL (pikaqqpika@gmail.com)
+ 
+const std = @import("std");
+
+// 递归函数
+fn recur(n: i32) i32 {
+    // 终止条件
+    if (n == 1) {
+        return 1;
+    }
+    // 递：递归调用
+    var res: i32 = recur(n - 1);
+    // 归：返回结果
+    return n + res;
+}
+
+// 使用迭代模拟递归
+fn forLoopRecur(comptime n: i32) i32 {
+    // 使用一个显式的栈来模拟系统调用栈
+    var stack: [n]i32 = undefined;
+    var res: i32 = 0;
+    // 递：递归调用
+    var i: usize = n;
+    while (i > 0) {
+        stack[i - 1] = @intCast(i);
+        i -= 1;
+    }
+    // 归：返回结果
+    var index: usize = n;
+    while (index > 0) {
+        index -= 1;
+        res += stack[index];
+    }
+    // res = 1+2+3+...+n
+    return res;
+}
+
+// 尾递归函数
+fn tailRecur(n: i32, res: i32) i32 {
+    // 终止条件
+    if (n == 0) {
+        return res;
+    }
+    // 尾递归调用
+    return tailRecur(n - 1, res + n);
+}
+
+// 斐波那契数列
+fn fib(n: i32) i32 {
+    // 终止条件 f(1) = 0, f(2) = 1
+    if (n == 1 or n == 2) {
+        return n - 1;
+    }
+    // 递归调用 f(n) = f(n-1) + f(n-2)
+    var res: i32 = fib(n - 1) + fib(n - 2);
+    // 返回结果 f(n)
+    return res;
+}
+
+// Driver Code
+pub fn main() !void {
+    const n: i32 = 5;
+    var res: i32 = 0;
+
+    res = recur(n);
+    std.debug.print("\n递归函数的求和结果 res = {}\n", .{recur(n)});
+
+    res = forLoopRecur(n);
+    std.debug.print("\n使用迭代模拟递归的求和结果 res = {}\n", .{forLoopRecur(n)});
+
+    res = tailRecur(n, 0);
+    std.debug.print("\n尾递归函数的求和结果 res = {}\n", .{tailRecur(n, 0)});
+
+    res = fib(n);
+    std.debug.print("\n斐波那契数列的第 {} 项为 {}\n", .{n, fib(n)});
+}

docs/chapter_computational_complexity/time_complexity.md

@@ -174,7 +174,16 @@
 === "Zig"
 
     ```zig title=""
-
+    // 在某运行平台下
+    fn algorithm(n: usize) void {
+        var a: i32 = 2; // 1 ns
+        a += 1; // 1 ns
+        a *= 2; // 10 ns
+        // 循环 n 次
+        for (0..n) |_| { // 1 ns
+            std.debug.print("{}\n", .{0}); // 5 ns
+        }
+    }
     ```
 
 根据以上方法，可以得到算法运行时间为 $6n + 12$ ns ：
@@ -423,7 +432,24 @@ $$
 === "Zig"
 
     ```zig title=""
-
+    // 算法 A 的时间复杂度：常数阶
+    fn algorithm_A(n: usize) void {
+        _ = n;
+        std.debug.print("{}\n", .{0});
+    }
+    // 算法 B 的时间复杂度：线性阶
+    fn algorithm_B(n: i32) void {
+        for (0..n) |_| {
+            std.debug.print("{}\n", .{0});
+        }
+    }
+    // 算法 C 的时间复杂度：常数阶
+    fn algorithm_C(n: i32) void {
+        _ = n;
+        for (0..1000000) |_| { 
+            std.debug.print("{}\n", .{0});
+        }
+    }
     ```
 
 下图展示了以上三个算法函数的时间复杂度。
@@ -600,7 +626,15 @@ $$
 === "Zig"
 
     ```zig title=""
-
+    fn algorithm(n: usize) void {
+        var a: i32 = 1; // +1
+        a += 1; // +1
+        a *= 2; // +1
+        // 循环 n 次
+        for (0..n) |_| { // +1（每轮都执行 i ++）
+            std.debug.print("{}\n", .{0}); // +1
+        }
+    }
     ```
 
 设算法的操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
@@ -849,7 +883,22 @@ $T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因
 === "Zig"
 
     ```zig title=""
+    fn algorithm(n: usize) void {
+        var a: i32 = 1;     // +0（技巧 1）
+        a = a + @as(i32, @intCast(n));        // +0（技巧 1）
 
+        // +n（技巧 2）
+        for(0..(5 * n + 1)) |_| {
+            std.debug.print("{}\n", .{0}); 
+        }
+
+        // +n*n（技巧 3）
+        for(0..(2 * n)) |_| {
+            for(0..(n + 1)) |_| {
+                std.debug.print("{}\n", .{0}); 
+            }
+        }
+    }
     ```
 
 以下公式展示了使用上述技巧前后的统计结果，两者推出的时间复杂度都为 $O(n^2)$ 。