feat: Traditional Chinese version (#1163)

* First commit * Update mkdocs.yml * Translate all the docs to traditional Chinese * Translate the code files. * Translate the docker file * Fix mkdocs.yml * Translate all the figures from SC to TC * 二叉搜尋樹 -> 二元搜尋樹 * Update terminology. * Update terminology * 构造函数/构造方法 -> 建構子异或 -> 互斥或 * 擴充套件 -> 擴展 * constant - 常量 - 常數 * 類 -> 類別 * AVL -> AVL 樹 * 數組 -> 陣列 * 係統 -> 系統斐波那契數列 -> 費波那契數列運算元量 -> 運算量引數 -> 參數 * 聯絡 -> 關聯 * 麵試 -> 面試 * 面向物件 -> 物件導向歸併排序 -> 合併排序范式 -> 範式 * Fix 算法 -> 演算法 * 錶示 -> 表示反碼 -> 一補數補碼 -> 二補數列列尾部 -> 佇列尾部區域性性 -> 區域性一摞 -> 一疊 * Synchronize with main branch * 賬號 -> 帳號推匯 -> 推導 * Sync with main branch * First commit * Update mkdocs.yml * Translate all the docs to traditional Chinese * Translate the code files. * Translate the docker file * Fix mkdocs.yml * Translate all the figures from SC to TC * 二叉搜尋樹 -> 二元搜尋樹 * Update terminology * 构造函数/构造方法 -> 建構子异或 -> 互斥或 * 擴充套件 -> 擴展 * constant - 常量 - 常數 * 類 -> 類別 * AVL -> AVL 樹 * 數組 -> 陣列 * 係統 -> 系統斐波那契數列 -> 費波那契數列運算元量 -> 運算量引數 -> 參數 * 聯絡 -> 關聯 * 麵試 -> 面試 * 面向物件 -> 物件導向歸併排序 -> 合併排序范式 -> 範式 * Fix 算法 -> 演算法 * 錶示 -> 表示反碼 -> 一補數補碼 -> 二補數列列尾部 -> 佇列尾部區域性性 -> 區域性一摞 -> 一疊 * Synchronize with main branch * 賬號 -> 帳號推匯 -> 推導 * Sync with main branch * Update terminology.md * 操作数量（num. of operations）-> 操作數量 * 字首和->前綴和 * Update figures * 歸 -> 迴記憶體洩漏 -> 記憶體流失 * Fix the bug of the file filter * 支援 -> 支持 Add zh-Hant/README.md * Add the zh-Hant chapter covers. Bug fixes. * 外掛 -> 擴充功能 * Add the landing page for zh-Hant version * Unify the font of the chapter covers for the zh, en, and zh-Hant version * Move zh-Hant/ to zh-hant/ * Translate terminology.md to traditional Chinese
2026-08-11 03:10:58 +00:00 · 2024-04-06 02:30:11 +08:00
parent 33d7f8a2e5
commit 5f7385c8a3
1875 changed files with 102923 additions and 18 deletions
@@ -0,0 +1,117 @@
+// File: array.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 隨機訪問元素
+pub fn randomAccess(nums: []i32) i32 {
+    // 在區間 [0, nums.len) 中隨機抽取一個整數
+    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
+    // 獲取並返回隨機元素
+    var randomNum = nums[randomIndex];
+    return randomNum;
+}
+
+// 擴展陣列長度
+pub fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
+    // 初始化一個擴展長度後的陣列
+    var res = try mem_allocator.alloc(i32, nums.len + enlarge);
+    @memset(res, 0);
+    // 將原陣列中的所有元素複製到新陣列
+    std.mem.copy(i32, res, nums);
+    // 返回擴展後的新陣列
+    return res;
+}
+
+// 在陣列的索引 index 處插入元素 num
+pub fn insert(nums: []i32, num: i32, index: usize) void {
+    // 把索引 index 以及之後的所有元素向後移動一位
+    var i = nums.len - 1;
+    while (i > index) : (i -= 1) {
+        nums[i] = nums[i - 1];
+    }
+    // 將 num 賦給 index 處的元素
+    nums[index] = num;
+}
+
+// 刪除索引 index 處的元素
+pub fn remove(nums: []i32, index: usize) void {
+    // 把索引 index 之後的所有元素向前移動一位
+    var i = index;
+    while (i < nums.len - 1) : (i += 1) {
+        nums[i] = nums[i + 1];
+    }
+}
+
+// 走訪陣列
+pub fn traverse(nums: []i32) void {
+    var count: i32 = 0;
+    // 透過索引走訪陣列
+    var i: i32 = 0;
+    while (i < nums.len) : (i += 1) {
+        count += nums[i];
+    }
+    count = 0;
+    // 直接走訪陣列元素
+    for (nums) |num| {
+        count += num;
+    }
+}
+
+// 在陣列中查詢指定元素
+pub fn find(nums: []i32, target: i32) i32 {
+    for (nums, 0..) |num, i| {
+        if (num == target) return @intCast(i);
+    }
+    return -1;
+}
+
+// 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 arr = [_]i32{0} ** 5;
+    std.debug.print("陣列 arr = ", .{});
+    inc.PrintUtil.printArray(i32, &arr);
+
+    var array = [_]i32{ 1, 3, 2, 5, 4 };
+    var known_at_runtime_zero: usize = 0;
+    var nums = array[known_at_runtime_zero..];
+    std.debug.print("\n陣列 nums = ", .{});
+    inc.PrintUtil.printArray(i32, nums);
+
+    // 隨機訪問
+    var randomNum = randomAccess(nums);
+    std.debug.print("\n在 nums 中獲取隨機元素 {}", .{randomNum});
+
+    // 長度擴展
+    nums = try extend(mem_allocator, nums, 3);
+    std.debug.print("\n將陣列長度擴展至 8 ，得到 nums = ", .{});
+    inc.PrintUtil.printArray(i32, nums);
+
+    // 插入元素
+    insert(nums, 6, 3);
+    std.debug.print("\n在索引 3 處插入數字 6 ，得到 nums = ", .{});
+    inc.PrintUtil.printArray(i32, nums);
+
+    // 刪除元素
+    remove(nums, 2);
+    std.debug.print("\n刪除索引 2 處的元素，得到 nums = ", .{});
+    inc.PrintUtil.printArray(i32, nums);
+
+    // 走訪陣列
+    traverse(nums);
+
+    // 查詢元素
+    var index = find(nums, 3);
+    std.debug.print("\n在 nums 中查詢元素 3 ，得到索引 = {}\n", .{index});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
+
@@ -0,0 +1,84 @@
+// File: linked_list.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 在鏈結串列的節點 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 之後的首個節點
+pub fn remove(n0: ?*inc.ListNode(i32)) void {
+    if (n0.?.next == null) return;
+    // n0 -> P -> n1
+    var P = n0.?.next;
+    var n1 = P.?.next;
+    n0.?.next = n1;
+}
+
+// 訪問鏈結串列中索引為 index 的節點
+pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
+    var head = node;
+    var i: i32 = 0;
+    while (i < index) : (i += 1) {
+        head = head.?.next;
+        if (head == null) return null;
+    }
+    return head;
+}
+
+// 在鏈結串列中查詢值為 target 的首個節點
+pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
+    var head = node;
+    var index: i32 = 0;
+    while (head != null) {
+        if (head.?.val == target) return index;
+        head = head.?.next;
+        index += 1;
+    }
+    return -1;
+}
+
+// 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};
+    var n3 = inc.ListNode(i32){.val = 5};
+    var n4 = inc.ListNode(i32){.val = 4};
+    // 構建節點之間的引用
+    n0.next = &n1;
+    n1.next = &n2;
+    n2.next = &n3;
+    n3.next = &n4;
+    std.debug.print("初始化的鏈結串列為", .{});
+    try inc.PrintUtil.printLinkedList(i32, &n0);
+
+    // 插入節點
+    var tmp = inc.ListNode(i32){.val = 0};
+    insert(&n0, &tmp);
+    std.debug.print("插入節點後的鏈結串列為", .{});
+    try inc.PrintUtil.printLinkedList(i32, &n0);
+
+    // 刪除節點
+    remove(&n0);
+    std.debug.print("刪除節點後的鏈結串列為", .{});
+    try inc.PrintUtil.printLinkedList(i32, &n0);
+
+    // 訪問節點
+    var node = access(&n0, 3);
+    std.debug.print("鏈結串列中索引 3 處的節點的值 = {}\n", .{node.?.val});
+
+    // 查詢節點
+    var index = find(&n0, 2);
+    std.debug.print("鏈結串列中值為 2 的節點的索引 = {}\n", .{index});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
@@ -0,0 +1,78 @@
+// File: list.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Driver Code
+pub fn main() !void {
+    // 初始化串列
+    var nums = std.ArrayList(i32).init(std.heap.page_allocator);
+    // 延遲釋放記憶體
+    defer nums.deinit();
+    try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
+    std.debug.print("串列 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 訪問元素
+    var num = nums.items[1];
+    std.debug.print("\n訪問索引 1 處的元素，得到 num = {}", .{num});
+
+    // 更新元素
+    nums.items[1] = 0;
+    std.debug.print("\n將索引 1 處的元素更新為 0 ，得到 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 清空串列
+    nums.clearRetainingCapacity();
+    std.debug.print("\n清空串列後 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 在尾部新增元素
+    try nums.append(1);
+    try nums.append(3);
+    try nums.append(2);
+    try nums.append(5);
+    try nums.append(4);
+    std.debug.print("\n新增元素後 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 在中間插入元素
+    try nums.insert(3, 6);
+    std.debug.print("\n在索引 3 處插入數字 6 ，得到 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 刪除元素
+    _ = nums.orderedRemove(3);
+    std.debug.print("\n刪除索引 3 處的元素，得到 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 透過索引走訪串列
+    var count: i32 = 0;
+    var i: i32 = 0;
+    while (i < nums.items.len) : (i += 1) {
+        count += nums[i];
+    }
+    // 直接走訪串列元素
+    count = 0;
+    for (nums.items) |x| {
+        count += x;
+    }
+
+    // 拼接兩個串列
+    var nums1 = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums1.deinit();
+    try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
+    try nums.insertSlice(nums.items.len, nums1.items);
+    std.debug.print("\n將串列 nums1 拼接到 nums 之後，得到 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    // 排序串列
+    std.mem.sort(i32, nums.items, {}, comptime std.sort.asc(i32));
+    std.debug.print("\n排序串列後 nums = ", .{});
+    inc.PrintUtil.printList(i32, nums);
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
+
@@ -0,0 +1,173 @@
+// File: my_list.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 串列類別
+pub fn MyList(comptime T: type) type {
+    return struct {
+        const Self = @This();
+        
+        arr: []T = undefined,                        // 陣列（儲存串列元素）
+        arrCapacity: usize = 10,                     // 串列容量
+        numSize: usize = 0,                           // 串列長度（當前元素數量）
+        extendRatio: usize = 2,                       // 每次串列擴容的倍數
+        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.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
+            @memset(self.arr, @as(T, 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.numSize;
+        }
+
+        // 獲取串列容量
+        pub fn capacity(self: *Self) usize {
+            return self.arrCapacity;
+        }
+
+        // 訪問元素
+        pub fn get(self: *Self, index: usize) T {
+            // 索引如果越界，則丟擲異常，下同
+            if (index < 0 or index >= self.size()) @panic("索引越界");
+            return self.arr[index];
+        }  
+
+        // 更新元素
+        pub fn set(self: *Self, index: usize, num: T) void {
+            // 索引如果越界，則丟擲異常，下同
+            if (index < 0 or index >= self.size()) @panic("索引越界");
+            self.arr[index] = num;
+        }  
+
+        // 在尾部新增元素
+        pub fn add(self: *Self, num: T) !void {
+            // 元素數量超出容量時，觸發擴容機制
+            if (self.size() == self.capacity()) try self.extendCapacity();
+            self.arr[self.size()] = num;
+            // 更新元素數量
+            self.numSize += 1;
+        }  
+
+        // 在中間插入元素
+        pub fn insert(self: *Self, index: usize, num: T) !void {
+            if (index < 0 or index >= self.size()) @panic("索引越界");
+            // 元素數量超出容量時，觸發擴容機制
+            if (self.size() == self.capacity()) try self.extendCapacity();
+            // 將索引 index 以及之後的元素都向後移動一位
+            var j = self.size() - 1;
+            while (j >= index) : (j -= 1) {
+                self.arr[j + 1] = self.arr[j];
+            }
+            self.arr[index] = num;
+            // 更新元素數量
+            self.numSize += 1;
+        }
+
+        // 刪除元素
+        pub fn remove(self: *Self, index: usize) T {
+            if (index < 0 or index >= self.size()) @panic("索引越界");
+            var num = self.arr[index];
+            // 將索引 index 之後的元素都向前移動一位
+            var j = index;
+            while (j < self.size() - 1) : (j += 1) {
+                self.arr[j] = self.arr[j + 1];
+            }
+            // 更新元素數量
+            self.numSize -= 1;
+            // 返回被刪除的元素
+            return num;
+        }
+
+        // 串列擴容
+        pub fn extendCapacity(self: *Self) !void {
+            // 新建一個長度為 size * extendRatio 的陣列，並將原陣列複製到新陣列
+            var newCapacity = self.capacity() * self.extendRatio;
+            var extend = try self.mem_allocator.alloc(T, newCapacity);
+            @memset(extend, @as(T, 0));
+            // 將原陣列中的所有元素複製到新陣列
+            std.mem.copy(T, extend, self.arr);
+            self.arr = extend;
+            // 更新串列容量
+            self.arrCapacity = newCapacity;
+        }
+
+        // 將串列轉換為陣列
+        pub fn toArray(self: *Self) ![]T {
+            // 僅轉換有效長度範圍內的串列元素
+            var arr = try self.mem_allocator.alloc(T, self.size());
+           @memset(arr, @as(T, 0));
+            for (arr, 0..) |*num, i| {
+                num.* = self.get(i);
+            }
+            return arr;
+        }
+    };
+}
+
+// Driver Code
+pub fn main() !void {
+    // 初始化串列
+    var nums = MyList(i32){};
+    try nums.init(std.heap.page_allocator);
+    // 延遲釋放記憶體
+    defer nums.deinit();
+
+    // 在尾部新增元素
+    try nums.add(1);
+    try nums.add(3);
+    try nums.add(2);
+    try nums.add(5);
+    try nums.add(4);
+    std.debug.print("串列 nums = ", .{});
+    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(" ，容量 = {} ，長度 = {}", .{nums.capacity(), nums.size()});
+
+    // 在中間插入元素
+    try nums.insert(3, 6);
+    std.debug.print("\n在索引 3 處插入數字 6 ，得到 nums = ", .{});
+    inc.PrintUtil.printArray(i32, try nums.toArray());
+
+    // 刪除元素
+    _ = nums.remove(3);
+    std.debug.print("\n刪除索引 3 處的元素，得到 nums = ", .{});
+    inc.PrintUtil.printArray(i32, try nums.toArray());
+
+    // 訪問元素
+    var num = nums.get(1);
+    std.debug.print("\n訪問索引 1 處的元素，得到 num = {}", .{num});
+
+    // 更新元素
+    nums.set(1, 0);
+    std.debug.print("\n將索引 1 處的元素更新為 0 ，得到 nums = ", .{});
+    inc.PrintUtil.printArray(i32, try nums.toArray());
+
+    // 測試擴容機制
+    var i: i32 = 0;
+    while (i < 10) : (i += 1) {
+        // 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
+        try nums.add(i);
+    }
+    std.debug.print("\n擴容後的串列 nums = ", .{});
+    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(" ，容量 = {} ，長度 = {}\n", .{nums.capacity(), nums.size()});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}