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
This commit is contained in:
Yudong Jin
2024-04-06 02:30:11 +08:00
committed by GitHub
parent 33d7f8a2e5
commit 5f7385c8a3
1875 changed files with 102923 additions and 18 deletions
@@ -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, 10, ...
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});
}
@@ -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)});
}
@@ -0,0 +1,124 @@
// File: space_complexity.zig
// Created Time: 2023-01-07
// Author: codingonion (coderonion@gmail.com)
const std = @import("std");
const inc = @import("include");
// 函式
fn function() i32 {
// 執行某些操作
return 0;
}
// 常數階
fn constant(n: i32) void {
// 常數、變數、物件佔用 O(1) 空間
const a: i32 = 0;
var b: i32 = 0;
var nums = [_]i32{0}**10000;
var node = inc.ListNode(i32){.val = 0};
var i: i32 = 0;
// 迴圈中的變數佔用 O(1) 空間
while (i < n) : (i += 1) {
var c: i32 = 0;
_ = c;
}
// 迴圈中的函式佔用 O(1) 空間
i = 0;
while (i < n) : (i += 1) {
_ = function();
}
_ = a;
_ = b;
_ = nums;
_ = node;
}
// 線性階
fn linear(comptime n: i32) !void {
// 長度為 n 的陣列佔用 O(n) 空間
var nums = [_]i32{0}**n;
// 長度為 n 的串列佔用 O(n) 空間
var nodes = std.ArrayList(i32).init(std.heap.page_allocator);
defer nodes.deinit();
var i: i32 = 0;
while (i < n) : (i += 1) {
try nodes.append(i);
}
// 長度為 n 的雜湊表佔用 O(n) 空間
var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);
defer map.deinit();
var j: i32 = 0;
while (j < n) : (j += 1) {
const string = try std.fmt.allocPrint(std.heap.page_allocator, "{d}", .{j});
defer std.heap.page_allocator.free(string);
try map.put(i, string);
}
_ = nums;
}
// 線性階(遞迴實現)
fn linearRecur(comptime n: i32) void {
std.debug.print("遞迴 n = {}\n", .{n});
if (n == 1) return;
linearRecur(n - 1);
}
// 平方階
fn quadratic(n: i32) !void {
// 二維串列佔用 O(n^2) 空間
var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);
defer nodes.deinit();
var i: i32 = 0;
while (i < n) : (i += 1) {
var tmp = std.ArrayList(i32).init(std.heap.page_allocator);
defer tmp.deinit();
var j: i32 = 0;
while (j < n) : (j += 1) {
try tmp.append(0);
}
try nodes.append(tmp);
}
}
// 平方階(遞迴實現)
fn quadraticRecur(comptime n: i32) i32 {
if (n <= 0) return 0;
var nums = [_]i32{0}**n;
std.debug.print("遞迴 n = {} 中的 nums 長度 = {}\n", .{n, nums.len});
return quadraticRecur(n - 1);
}
// 指數階(建立滿二元樹)
fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
if (n == 0) return null;
const root = try mem_allocator.create(inc.TreeNode(i32));
root.init(0);
root.left = try buildTree(mem_allocator, n - 1);
root.right = try buildTree(mem_allocator, n - 1);
return root;
}
// Driver Code
pub fn main() !void {
const n: i32 = 5;
// 常數階
constant(n);
// 線性階
try linear(n);
linearRecur(n);
// 平方階
try quadratic(n);
_ = quadraticRecur(n);
// 指數階
var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer mem_arena.deinit();
var root = blk_root: {
const mem_allocator = mem_arena.allocator();
break :blk_root try buildTree(mem_allocator, n);
};
try inc.PrintUtil.printTree(root, null, false);
_ = try std.io.getStdIn().reader().readByte();
}
@@ -0,0 +1,179 @@
// File: time_complexity.zig
// Created Time: 2022-12-28
// Author: codingonion (coderonion@gmail.com)
const std = @import("std");
// 常數階
fn constant(n: i32) i32 {
_ = n;
var count: i32 = 0;
const size: i32 = 100_000;
var i: i32 = 0;
while(i<size) : (i += 1) {
count += 1;
}
return count;
}
// 線性階
fn linear(n: i32) i32 {
var count: i32 = 0;
var i: i32 = 0;
while (i < n) : (i += 1) {
count += 1;
}
return count;
}
// 線性階(走訪陣列)
fn arrayTraversal(nums: []i32) i32 {
var count: i32 = 0;
// 迴圈次數與陣列長度成正比
for (nums) |_| {
count += 1;
}
return count;
}
// 平方階
fn quadratic(n: i32) i32 {
var count: i32 = 0;
var i: i32 = 0;
// 迴圈次數與資料大小 n 成平方關係
while (i < n) : (i += 1) {
var j: i32 = 0;
while (j < n) : (j += 1) {
count += 1;
}
}
return count;
}
// 平方階(泡沫排序)
fn bubbleSort(nums: []i32) i32 {
var count: i32 = 0; // 計數器
// 外迴圈:未排序區間為 [0, i]
var i: i32 = @as(i32, @intCast(nums.len)) - 1;
while (i > 0) : (i -= 1) {
var j: usize = 0;
// 內迴圈:將未排序區間 [0, i] 中的最大元素交換至該區間的最右端
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;
count += 3; // 元素交換包含 3 個單元操作
}
}
}
return count;
}
// 指數階(迴圈實現)
fn exponential(n: i32) i32 {
var count: i32 = 0;
var bas: i32 = 1;
var i: i32 = 0;
// 細胞每輪一分為二,形成數列 1, 2, 4, 8, ..., 2^(n-1)
while (i < n) : (i += 1) {
var j: i32 = 0;
while (j < bas) : (j += 1) {
count += 1;
}
bas *= 2;
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count;
}
// 指數階(遞迴實現)
fn expRecur(n: i32) i32 {
if (n == 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
// 對數階(迴圈實現)
fn logarithmic(n: i32) i32 {
var count: i32 = 0;
var n_var = n;
while (n_var > 1)
{
n_var = n_var / 2;
count +=1;
}
return count;
}
// 對數階(遞迴實現)
fn logRecur(n: i32) i32 {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
}
// 線性對數階
fn linearLogRecur(n: i32) i32 {
if (n <= 1) return 1;
var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);
var i: i32 = 0;
while (i < n) : (i += 1) {
count += 1;
}
return count;
}
// 階乘階(遞迴實現)
fn factorialRecur(n: i32) i32 {
if (n == 0) return 1;
var count: i32 = 0;
var i: i32 = 0;
// 從 1 個分裂出 n 個
while (i < n) : (i += 1) {
count += factorialRecur(n - 1);
}
return count;
}
// Driver Code
pub fn main() !void {
// 可以修改 n 執行,體會一下各種複雜度的操作數量變化趨勢
const n: i32 = 8;
std.debug.print("輸入資料大小 n = {}\n", .{n});
var count = constant(n);
std.debug.print("常數階的操作數量 = {}\n", .{count});
count = linear(n);
std.debug.print("線性階的操作數量 = {}\n", .{count});
var nums = [_]i32{0}**n;
count = arrayTraversal(&nums);
std.debug.print("線性階(走訪陣列)的操作數量 = {}\n", .{count});
count = quadratic(n);
std.debug.print("平方階的操作數量 = {}\n", .{count});
for (&nums, 0..) |*num, i| {
num.* = n - @as(i32, @intCast(i)); // [n,n-1,...,2,1]
}
count = bubbleSort(&nums);
std.debug.print("平方階(泡沫排序)的操作數量 = {}\n", .{count});
count = exponential(n);
std.debug.print("指數階(迴圈實現)的操作數量 = {}\n", .{count});
count = expRecur(n);
std.debug.print("指數階(遞迴實現)的操作數量 = {}\n", .{count});
count = logarithmic(n);
std.debug.print("對數階(迴圈實現)的操作數量 = {}\n", .{count});
count = logRecur(n);
std.debug.print("對數階(遞迴實現)的操作數量 = {}\n", .{count});
count = linearLogRecur(n);
std.debug.print("線性對數階(遞迴實現)的操作數量 = {}\n", .{count});
count = factorialRecur(n);
std.debug.print("階乘階(遞迴實現)的操作數量 = {}\n", .{count});
_ = try std.io.getStdIn().reader().readByte();
}
@@ -0,0 +1,45 @@
// File: worst_best_time_complexity.zig
// Created Time: 2022-12-28
// Author: codingonion (coderonion@gmail.com)
const std = @import("std");
const inc = @import("include");
// 生成一個陣列,元素為 { 1, 2, ..., n },順序被打亂
pub fn randomNumbers(comptime n: usize) [n]i32 {
var nums: [n]i32 = undefined;
// 生成陣列 nums = { 1, 2, 3, ..., n }
for (&nums, 0..) |*num, i| {
num.* = @as(i32, @intCast(i)) + 1;
}
// 隨機打亂陣列元素
const rand = std.crypto.random;
rand.shuffle(i32, &nums);
return nums;
}
// 查詢陣列 nums 中數字 1 所在索引
pub fn findOne(nums: []i32) i32 {
for (nums, 0..) |num, i| {
// 當元素 1 在陣列頭部時,達到最佳時間複雜度 O(1)
// 當元素 1 在陣列尾部時,達到最差時間複雜度 O(n)
if (num == 1) return @intCast(i);
}
return -1;
}
// Driver Code
pub fn main() !void {
var i: i32 = 0;
while (i < 10) : (i += 1) {
const n: usize = 100;
var nums = randomNumbers(n);
var index = findOne(&nums);
std.debug.print("\n陣列 [ 1, 2, ..., n ] 被打亂後 = ", .{});
inc.PrintUtil.printArray(i32, &nums);
std.debug.print("數字 1 的索引為 {}\n", .{index});
}
_ = try std.io.getStdIn().reader().readByte();
}