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,129 @@
/**
* File: array_binary_tree.cs
* Created Time: 2023-07-20
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_tree;
/* 陣列表示下的二元樹類別 */
public class ArrayBinaryTree(List<int?> arr) {
List<int?> tree = new(arr);
/* 串列容量 */
public int Size() {
return tree.Count;
}
/* 獲取索引為 i 節點的值 */
public int? Val(int i) {
// 若索引越界,則返回 null ,代表空位
if (i < 0 || i >= Size())
return null;
return tree[i];
}
/* 獲取索引為 i 節點的左子節點的索引 */
public int Left(int i) {
return 2 * i + 1;
}
/* 獲取索引為 i 節點的右子節點的索引 */
public int Right(int i) {
return 2 * i + 2;
}
/* 獲取索引為 i 節點的父節點的索引 */
public int Parent(int i) {
return (i - 1) / 2;
}
/* 層序走訪 */
public List<int> LevelOrder() {
List<int> res = [];
// 直接走訪陣列
for (int i = 0; i < Size(); i++) {
if (Val(i).HasValue)
res.Add(Val(i)!.Value);
}
return res;
}
/* 深度優先走訪 */
void DFS(int i, string order, List<int> res) {
// 若為空位,則返回
if (!Val(i).HasValue)
return;
// 前序走訪
if (order == "pre")
res.Add(Val(i)!.Value);
DFS(Left(i), order, res);
// 中序走訪
if (order == "in")
res.Add(Val(i)!.Value);
DFS(Right(i), order, res);
// 後序走訪
if (order == "post")
res.Add(Val(i)!.Value);
}
/* 前序走訪 */
public List<int> PreOrder() {
List<int> res = [];
DFS(0, "pre", res);
return res;
}
/* 中序走訪 */
public List<int> InOrder() {
List<int> res = [];
DFS(0, "in", res);
return res;
}
/* 後序走訪 */
public List<int> PostOrder() {
List<int> res = [];
DFS(0, "post", res);
return res;
}
}
public class array_binary_tree {
[Test]
public void Test() {
// 初始化二元樹
// 這裡藉助了一個從陣列直接生成二元樹的函式
List<int?> arr = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
TreeNode? root = TreeNode.ListToTree(arr);
Console.WriteLine("\n初始化二元樹\n");
Console.WriteLine("二元樹的陣列表示:");
Console.WriteLine(arr.PrintList());
Console.WriteLine("二元樹的鏈結串列表示:");
PrintUtil.PrintTree(root);
// 陣列表示下的二元樹類別
ArrayBinaryTree abt = new(arr);
// 訪問節點
int i = 1;
int l = abt.Left(i);
int r = abt.Right(i);
int p = abt.Parent(i);
Console.WriteLine("\n當前節點的索引為 " + i + " ,值為 " + abt.Val(i));
Console.WriteLine("其左子節點的索引為 " + l + " ,值為 " + (abt.Val(l).HasValue ? abt.Val(l) : "null"));
Console.WriteLine("其右子節點的索引為 " + r + " ,值為 " + (abt.Val(r).HasValue ? abt.Val(r) : "null"));
Console.WriteLine("其父節點的索引為 " + p + " ,值為 " + (abt.Val(p).HasValue ? abt.Val(p) : "null"));
// 走訪樹
List<int> res = abt.LevelOrder();
Console.WriteLine("\n層序走訪為:" + res.PrintList());
res = abt.PreOrder();
Console.WriteLine("前序走訪為:" + res.PrintList());
res = abt.InOrder();
Console.WriteLine("中序走訪為:" + res.PrintList());
res = abt.PostOrder();
Console.WriteLine("後序走訪為:" + res.PrintList());
}
}
@@ -0,0 +1,216 @@
/**
* File: avl_tree.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_tree;
/* AVL 樹 */
class AVLTree {
public TreeNode? root; // 根節點
/* 獲取節點高度 */
int Height(TreeNode? node) {
// 空節點高度為 -1 ,葉節點高度為 0
return node == null ? -1 : node.height;
}
/* 更新節點高度 */
void UpdateHeight(TreeNode node) {
// 節點高度等於最高子樹高度 + 1
node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
}
/* 獲取平衡因子 */
public int BalanceFactor(TreeNode? node) {
// 空節點平衡因子為 0
if (node == null) return 0;
// 節點平衡因子 = 左子樹高度 - 右子樹高度
return Height(node.left) - Height(node.right);
}
/* 右旋操作 */
TreeNode? RightRotate(TreeNode? node) {
TreeNode? child = node?.left;
TreeNode? grandChild = child?.right;
// 以 child 為原點,將 node 向右旋轉
child.right = node;
node.left = grandChild;
// 更新節點高度
UpdateHeight(node);
UpdateHeight(child);
// 返回旋轉後子樹的根節點
return child;
}
/* 左旋操作 */
TreeNode? LeftRotate(TreeNode? node) {
TreeNode? child = node?.right;
TreeNode? grandChild = child?.left;
// 以 child 為原點,將 node 向左旋轉
child.left = node;
node.right = grandChild;
// 更新節點高度
UpdateHeight(node);
UpdateHeight(child);
// 返回旋轉後子樹的根節點
return child;
}
/* 執行旋轉操作,使該子樹重新恢復平衡 */
TreeNode? Rotate(TreeNode? node) {
// 獲取節點 node 的平衡因子
int balanceFactorInt = BalanceFactor(node);
// 左偏樹
if (balanceFactorInt > 1) {
if (BalanceFactor(node?.left) >= 0) {
// 右旋
return RightRotate(node);
} else {
// 先左旋後右旋
node!.left = LeftRotate(node!.left);
return RightRotate(node);
}
}
// 右偏樹
if (balanceFactorInt < -1) {
if (BalanceFactor(node?.right) <= 0) {
// 左旋
return LeftRotate(node);
} else {
// 先右旋後左旋
node!.right = RightRotate(node!.right);
return LeftRotate(node);
}
}
// 平衡樹,無須旋轉,直接返回
return node;
}
/* 插入節點 */
public void Insert(int val) {
root = InsertHelper(root, val);
}
/* 遞迴插入節點(輔助方法) */
TreeNode? InsertHelper(TreeNode? node, int val) {
if (node == null) return new TreeNode(val);
/* 1. 查詢插入位置並插入節點 */
if (val < node.val)
node.left = InsertHelper(node.left, val);
else if (val > node.val)
node.right = InsertHelper(node.right, val);
else
return node; // 重複節點不插入,直接返回
UpdateHeight(node); // 更新節點高度
/* 2. 執行旋轉操作,使該子樹重新恢復平衡 */
node = Rotate(node);
// 返回子樹的根節點
return node;
}
/* 刪除節點 */
public void Remove(int val) {
root = RemoveHelper(root, val);
}
/* 遞迴刪除節點(輔助方法) */
TreeNode? RemoveHelper(TreeNode? node, int val) {
if (node == null) return null;
/* 1. 查詢節點並刪除 */
if (val < node.val)
node.left = RemoveHelper(node.left, val);
else if (val > node.val)
node.right = RemoveHelper(node.right, val);
else {
if (node.left == null || node.right == null) {
TreeNode? child = node.left ?? node.right;
// 子節點數量 = 0 ,直接刪除 node 並返回
if (child == null)
return null;
// 子節點數量 = 1 ,直接刪除 node
else
node = child;
} else {
// 子節點數量 = 2 ,則將中序走訪的下個節點刪除,並用該節點替換當前節點
TreeNode? temp = node.right;
while (temp.left != null) {
temp = temp.left;
}
node.right = RemoveHelper(node.right, temp.val!.Value);
node.val = temp.val;
}
}
UpdateHeight(node); // 更新節點高度
/* 2. 執行旋轉操作,使該子樹重新恢復平衡 */
node = Rotate(node);
// 返回子樹的根節點
return node;
}
/* 查詢節點 */
public TreeNode? Search(int val) {
TreeNode? cur = root;
// 迴圈查詢,越過葉節點後跳出
while (cur != null) {
// 目標節點在 cur 的右子樹中
if (cur.val < val)
cur = cur.right;
// 目標節點在 cur 的左子樹中
else if (cur.val > val)
cur = cur.left;
// 找到目標節點,跳出迴圈
else
break;
}
// 返回目標節點
return cur;
}
}
public class avl_tree {
static void TestInsert(AVLTree tree, int val) {
tree.Insert(val);
Console.WriteLine("\n插入節點 " + val + " 後,AVL 樹為");
PrintUtil.PrintTree(tree.root);
}
static void TestRemove(AVLTree tree, int val) {
tree.Remove(val);
Console.WriteLine("\n刪除節點 " + val + " 後,AVL 樹為");
PrintUtil.PrintTree(tree.root);
}
[Test]
public void Test() {
/* 初始化空 AVL 樹 */
AVLTree avlTree = new();
/* 插入節點 */
// 請關注插入節點後,AVL 樹是如何保持平衡的
TestInsert(avlTree, 1);
TestInsert(avlTree, 2);
TestInsert(avlTree, 3);
TestInsert(avlTree, 4);
TestInsert(avlTree, 5);
TestInsert(avlTree, 8);
TestInsert(avlTree, 7);
TestInsert(avlTree, 9);
TestInsert(avlTree, 10);
TestInsert(avlTree, 6);
/* 插入重複節點 */
TestInsert(avlTree, 7);
/* 刪除節點 */
// 請關注刪除節點後,AVL 樹是如何保持平衡的
TestRemove(avlTree, 8); // 刪除度為 0 的節點
TestRemove(avlTree, 5); // 刪除度為 1 的節點
TestRemove(avlTree, 4); // 刪除度為 2 的節點
/* 查詢節點 */
TreeNode? node = avlTree.Search(7);
Console.WriteLine("\n查詢到的節點物件為 " + node + ",節點值 = " + node?.val);
}
}
@@ -0,0 +1,160 @@
/**
* File: binary_search_tree.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_tree;
class BinarySearchTree {
TreeNode? root;
public BinarySearchTree() {
// 初始化空樹
root = null;
}
/* 獲取二元樹根節點 */
public TreeNode? GetRoot() {
return root;
}
/* 查詢節點 */
public TreeNode? Search(int num) {
TreeNode? cur = 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;
}
/* 插入節點 */
public void Insert(int num) {
// 若樹為空,則初始化根節點
if (root == null) {
root = new TreeNode(num);
return;
}
TreeNode? cur = root, pre = null;
// 迴圈查詢,越過葉節點後跳出
while (cur != null) {
// 找到重複節點,直接返回
if (cur.val == num)
return;
pre = cur;
// 插入位置在 cur 的右子樹中
if (cur.val < num)
cur = cur.right;
// 插入位置在 cur 的左子樹中
else
cur = cur.left;
}
// 插入節點
TreeNode node = new(num);
if (pre != null) {
if (pre.val < num)
pre.right = node;
else
pre.left = node;
}
}
/* 刪除節點 */
public void Remove(int num) {
// 若樹為空,直接提前返回
if (root == null)
return;
TreeNode? cur = root, pre = 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;
// 子節點數量 = 0 or 1
if (cur.left == null || cur.right == null) {
// 當子節點數量 = 0 / 1 時, child = null / 該子節點
TreeNode? child = cur.left ?? cur.right;
// 刪除節點 cur
if (cur != root) {
if (pre!.left == cur)
pre.left = child;
else
pre.right = child;
} else {
// 若刪除節點為根節點,則重新指定根節點
root = child;
}
}
// 子節點數量 = 2
else {
// 獲取中序走訪中 cur 的下一個節點
TreeNode? tmp = cur.right;
while (tmp.left != null) {
tmp = tmp.left;
}
// 遞迴刪除節點 tmp
Remove(tmp.val!.Value);
// 用 tmp 覆蓋 cur
cur.val = tmp.val;
}
}
}
public class binary_search_tree {
[Test]
public void Test() {
/* 初始化二元搜尋樹 */
BinarySearchTree bst = new();
// 請注意,不同的插入順序會生成不同的二元樹,該序列可以生成一個完美二元樹
int[] nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
foreach (int num in nums) {
bst.Insert(num);
}
Console.WriteLine("\n初始化的二元樹為\n");
PrintUtil.PrintTree(bst.GetRoot());
/* 查詢節點 */
TreeNode? node = bst.Search(7);
Console.WriteLine("\n查詢到的節點物件為 " + node + ",節點值 = " + node?.val);
/* 插入節點 */
bst.Insert(16);
Console.WriteLine("\n插入節點 16 後,二元樹為\n");
PrintUtil.PrintTree(bst.GetRoot());
/* 刪除節點 */
bst.Remove(1);
Console.WriteLine("\n刪除節點 1 後,二元樹為\n");
PrintUtil.PrintTree(bst.GetRoot());
bst.Remove(2);
Console.WriteLine("\n刪除節點 2 後,二元樹為\n");
PrintUtil.PrintTree(bst.GetRoot());
bst.Remove(4);
Console.WriteLine("\n刪除節點 4 後,二元樹為\n");
PrintUtil.PrintTree(bst.GetRoot());
}
}
@@ -0,0 +1,39 @@
/**
* File: binary_tree.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_tree;
public class binary_tree {
[Test]
public void Test() {
/* 初始化二元樹 */
// 初始化節點
TreeNode n1 = new(1);
TreeNode n2 = new(2);
TreeNode n3 = new(3);
TreeNode n4 = new(4);
TreeNode n5 = new(5);
// 構建節點之間的引用(指標)
n1.left = n2;
n1.right = n3;
n2.left = n4;
n2.right = n5;
Console.WriteLine("\n初始化二元樹\n");
PrintUtil.PrintTree(n1);
/* 插入與刪除節點 */
TreeNode P = new(0);
// 在 n1 -> n2 中間插入節點 P
n1.left = P;
P.left = n2;
Console.WriteLine("\n插入節點 P 後\n");
PrintUtil.PrintTree(n1);
// 刪除節點 P
n1.left = n2;
Console.WriteLine("\n刪除節點 P 後\n");
PrintUtil.PrintTree(n1);
}
}
@@ -0,0 +1,40 @@
/**
* File: binary_tree_bfs.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_tree;
public class binary_tree_bfs {
/* 層序走訪 */
List<int> LevelOrder(TreeNode root) {
// 初始化佇列,加入根節點
Queue<TreeNode> queue = new();
queue.Enqueue(root);
// 初始化一個串列,用於儲存走訪序列
List<int> list = [];
while (queue.Count != 0) {
TreeNode node = queue.Dequeue(); // 隊列出隊
list.Add(node.val!.Value); // 儲存節點值
if (node.left != null)
queue.Enqueue(node.left); // 左子節點入列
if (node.right != null)
queue.Enqueue(node.right); // 右子節點入列
}
return list;
}
[Test]
public void Test() {
/* 初始化二元樹 */
// 這裡藉助了一個從陣列直接生成二元樹的函式
TreeNode? root = TreeNode.ListToTree([1, 2, 3, 4, 5, 6, 7]);
Console.WriteLine("\n初始化二元樹\n");
PrintUtil.PrintTree(root);
List<int> list = LevelOrder(root!);
Console.WriteLine("\n層序走訪的節點列印序列 = " + string.Join(",", list));
}
}
@@ -0,0 +1,59 @@
/**
* File: binary_tree_dfs.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_tree;
public class binary_tree_dfs {
List<int> list = [];
/* 前序走訪 */
void PreOrder(TreeNode? root) {
if (root == null) return;
// 訪問優先順序:根節點 -> 左子樹 -> 右子樹
list.Add(root.val!.Value);
PreOrder(root.left);
PreOrder(root.right);
}
/* 中序走訪 */
void InOrder(TreeNode? root) {
if (root == null) return;
// 訪問優先順序:左子樹 -> 根節點 -> 右子樹
InOrder(root.left);
list.Add(root.val!.Value);
InOrder(root.right);
}
/* 後序走訪 */
void PostOrder(TreeNode? root) {
if (root == null) return;
// 訪問優先順序:左子樹 -> 右子樹 -> 根節點
PostOrder(root.left);
PostOrder(root.right);
list.Add(root.val!.Value);
}
[Test]
public void Test() {
/* 初始化二元樹 */
// 這裡藉助了一個從陣列直接生成二元樹的函式
TreeNode? root = TreeNode.ListToTree([1, 2, 3, 4, 5, 6, 7]);
Console.WriteLine("\n初始化二元樹\n");
PrintUtil.PrintTree(root);
list.Clear();
PreOrder(root);
Console.WriteLine("\n前序走訪的節點列印序列 = " + string.Join(",", list));
list.Clear();
InOrder(root);
Console.WriteLine("\n中序走訪的節點列印序列 = " + string.Join(",", list));
list.Clear();
PostOrder(root);
Console.WriteLine("\n後序走訪的節點列印序列 = " + string.Join(",", list));
}
}