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

zh-hant/codes/python/chapter_tree/array_binary_tree.py

@@ -0,0 +1,119 @@
+"""
+File: array_binary_tree.py
+Created Time: 2023-07-19
+Author: krahets (krahets@163.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, list_to_tree, print_tree
+
+
+class ArrayBinaryTree:
+    """陣列表示下的二元樹類別"""
+
+    def __init__(self, arr: list[int | None]):
+        """建構子"""
+        self._tree = list(arr)
+
+    def size(self):
+        """串列容量"""
+        return len(self._tree)
+
+    def val(self, i: int) -> int:
+        """獲取索引為 i 節點的值"""
+        # 若索引越界，則返回 None ，代表空位
+        if i < 0 or i >= self.size():
+            return None
+        return self._tree[i]
+
+    def left(self, i: int) -> int | None:
+        """獲取索引為 i 節點的左子節點的索引"""
+        return 2 * i + 1
+
+    def right(self, i: int) -> int | None:
+        """獲取索引為 i 節點的右子節點的索引"""
+        return 2 * i + 2
+
+    def parent(self, i: int) -> int | None:
+        """獲取索引為 i 節點的父節點的索引"""
+        return (i - 1) // 2
+
+    def level_order(self) -> list[int]:
+        """層序走訪"""
+        self.res = []
+        # 直接走訪陣列
+        for i in range(self.size()):
+            if self.val(i) is not None:
+                self.res.append(self.val(i))
+        return self.res
+
+    def dfs(self, i: int, order: str):
+        """深度優先走訪"""
+        if self.val(i) is None:
+            return
+        # 前序走訪
+        if order == "pre":
+            self.res.append(self.val(i))
+        self.dfs(self.left(i), order)
+        # 中序走訪
+        if order == "in":
+            self.res.append(self.val(i))
+        self.dfs(self.right(i), order)
+        # 後序走訪
+        if order == "post":
+            self.res.append(self.val(i))
+
+    def pre_order(self) -> list[int]:
+        """前序走訪"""
+        self.res = []
+        self.dfs(0, order="pre")
+        return self.res
+
+    def in_order(self) -> list[int]:
+        """中序走訪"""
+        self.res = []
+        self.dfs(0, order="in")
+        return self.res
+
+    def post_order(self) -> list[int]:
+        """後序走訪"""
+        self.res = []
+        self.dfs(0, order="post")
+        return self.res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    # 初始化二元樹
+    # 這裡藉助了一個從陣列直接生成二元樹的函式
+    arr = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+    root = list_to_tree(arr)
+    print("\n初始化二元樹\n")
+    print("二元樹的陣列表示：")
+    print(arr)
+    print("二元樹的鏈結串列表示：")
+    print_tree(root)
+
+    # 陣列表示下的二元樹類別
+    abt = ArrayBinaryTree(arr)
+
+    # 訪問節點
+    i = 1
+    l, r, p = abt.left(i), abt.right(i), abt.parent(i)
+    print(f"\n當前節點的索引為 {i} ，值為 {abt.val(i)}")
+    print(f"其左子節點的索引為 {l} ，值為 {abt.val(l)}")
+    print(f"其右子節點的索引為 {r} ，值為 {abt.val(r)}")
+    print(f"其父節點的索引為 {p} ，值為 {abt.val(p)}")
+
+    # 走訪樹
+    res = abt.level_order()
+    print("\n層序走訪為：", res)
+    res = abt.pre_order()
+    print("前序走訪為：", res)
+    res = abt.in_order()
+    print("中序走訪為：", res)
+    res = abt.post_order()
+    print("後序走訪為：", res)

zh-hant/codes/python/chapter_tree/avl_tree.py

@@ -0,0 +1,200 @@
+"""
+File: avl_tree.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree
+
+
+class AVLTree:
+    """AVL 樹"""
+
+    def __init__(self):
+        """建構子"""
+        self._root = None
+
+    def get_root(self) -> TreeNode | None:
+        """獲取二元樹根節點"""
+        return self._root
+
+    def height(self, node: TreeNode | None) -> int:
+        """獲取節點高度"""
+        # 空節點高度為 -1 ，葉節點高度為 0
+        if node is not None:
+            return node.height
+        return -1
+
+    def update_height(self, node: TreeNode | None):
+        """更新節點高度"""
+        # 節點高度等於最高子樹高度 + 1
+        node.height = max([self.height(node.left), self.height(node.right)]) + 1
+
+    def balance_factor(self, node: TreeNode | None) -> int:
+        """獲取平衡因子"""
+        # 空節點平衡因子為 0
+        if node is None:
+            return 0
+        # 節點平衡因子 = 左子樹高度 - 右子樹高度
+        return self.height(node.left) - self.height(node.right)
+
+    def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
+        """右旋操作"""
+        child = node.left
+        grand_child = child.right
+        # 以 child 為原點，將 node 向右旋轉
+        child.right = node
+        node.left = grand_child
+        # 更新節點高度
+        self.update_height(node)
+        self.update_height(child)
+        # 返回旋轉後子樹的根節點
+        return child
+
+    def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
+        """左旋操作"""
+        child = node.right
+        grand_child = child.left
+        # 以 child 為原點，將 node 向左旋轉
+        child.left = node
+        node.right = grand_child
+        # 更新節點高度
+        self.update_height(node)
+        self.update_height(child)
+        # 返回旋轉後子樹的根節點
+        return child
+
+    def rotate(self, node: TreeNode | None) -> TreeNode | None:
+        """執行旋轉操作，使該子樹重新恢復平衡"""
+        # 獲取節點 node 的平衡因子
+        balance_factor = self.balance_factor(node)
+        # 左偏樹
+        if balance_factor > 1:
+            if self.balance_factor(node.left) >= 0:
+                # 右旋
+                return self.right_rotate(node)
+            else:
+                # 先左旋後右旋
+                node.left = self.left_rotate(node.left)
+                return self.right_rotate(node)
+        # 右偏樹
+        elif balance_factor < -1:
+            if self.balance_factor(node.right) <= 0:
+                # 左旋
+                return self.left_rotate(node)
+            else:
+                # 先右旋後左旋
+                node.right = self.right_rotate(node.right)
+                return self.left_rotate(node)
+        # 平衡樹，無須旋轉，直接返回
+        return node
+
+    def insert(self, val):
+        """插入節點"""
+        self._root = self.insert_helper(self._root, val)
+
+    def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
+        """遞迴插入節點（輔助方法）"""
+        if node is None:
+            return TreeNode(val)
+        # 1. 查詢插入位置並插入節點
+        if val < node.val:
+            node.left = self.insert_helper(node.left, val)
+        elif val > node.val:
+            node.right = self.insert_helper(node.right, val)
+        else:
+            # 重複節點不插入，直接返回
+            return node
+        # 更新節點高度
+        self.update_height(node)
+        # 2. 執行旋轉操作，使該子樹重新恢復平衡
+        return self.rotate(node)
+
+    def remove(self, val: int):
+        """刪除節點"""
+        self._root = self.remove_helper(self._root, val)
+
+    def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
+        """遞迴刪除節點（輔助方法）"""
+        if node is None:
+            return None
+        # 1. 查詢節點並刪除
+        if val < node.val:
+            node.left = self.remove_helper(node.left, val)
+        elif val > node.val:
+            node.right = self.remove_helper(node.right, val)
+        else:
+            if node.left is None or node.right is None:
+                child = node.left or node.right
+                # 子節點數量 = 0 ，直接刪除 node 並返回
+                if child is None:
+                    return None
+                # 子節點數量 = 1 ，直接刪除 node
+                else:
+                    node = child
+            else:
+                # 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點
+                temp = node.right
+                while temp.left is not None:
+                    temp = temp.left
+                node.right = self.remove_helper(node.right, temp.val)
+                node.val = temp.val
+        # 更新節點高度
+        self.update_height(node)
+        # 2. 執行旋轉操作，使該子樹重新恢復平衡
+        return self.rotate(node)
+
+    def search(self, val: int) -> TreeNode | None:
+        """查詢節點"""
+        cur = self._root
+        # 迴圈查詢，越過葉節點後跳出
+        while cur is not None:
+            # 目標節點在 cur 的右子樹中
+            if cur.val < val:
+                cur = cur.right
+            # 目標節點在 cur 的左子樹中
+            elif cur.val > val:
+                cur = cur.left
+            # 找到目標節點，跳出迴圈
+            else:
+                break
+        # 返回目標節點
+        return cur
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+
+    def test_insert(tree: AVLTree, val: int):
+        tree.insert(val)
+        print("\n插入節點 {} 後，AVL 樹為".format(val))
+        print_tree(tree.get_root())
+
+    def test_remove(tree: AVLTree, val: int):
+        tree.remove(val)
+        print("\n刪除節點 {} 後，AVL 樹為".format(val))
+        print_tree(tree.get_root())
+
+    # 初始化空 AVL 樹
+    avl_tree = AVLTree()
+
+    # 插入節點
+    # 請關注插入節點後，AVL 樹是如何保持平衡的
+    for val in [1, 2, 3, 4, 5, 8, 7, 9, 10, 6]:
+        test_insert(avl_tree, val)
+
+    # 插入重複節點
+    test_insert(avl_tree, 7)
+
+    # 刪除節點
+    # 請關注刪除節點後，AVL 樹是如何保持平衡的
+    test_remove(avl_tree, 8)  # 刪除度為 0 的節點
+    test_remove(avl_tree, 5)  # 刪除度為 1 的節點
+    test_remove(avl_tree, 4)  # 刪除度為 2 的節點
+
+    result_node = avl_tree.search(7)
+    print("\n查詢到的節點物件為 {}，節點值 = {}".format(result_node, result_node.val))

zh-hant/codes/python/chapter_tree/binary_search_tree.py

@@ -0,0 +1,146 @@
+"""
+File: binary_search_tree.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree
+
+
+class BinarySearchTree:
+    """二元搜尋樹"""
+
+    def __init__(self):
+        """建構子"""
+        # 初始化空樹
+        self._root = None
+
+    def get_root(self) -> TreeNode | None:
+        """獲取二元樹根節點"""
+        return self._root
+
+    def search(self, num: int) -> TreeNode | None:
+        """查詢節點"""
+        cur = self._root
+        # 迴圈查詢，越過葉節點後跳出
+        while cur is not None:
+            # 目標節點在 cur 的右子樹中
+            if cur.val < num:
+                cur = cur.right
+            # 目標節點在 cur 的左子樹中
+            elif cur.val > num:
+                cur = cur.left
+            # 找到目標節點，跳出迴圈
+            else:
+                break
+        return cur
+
+    def insert(self, num: int):
+        """插入節點"""
+        # 若樹為空，則初始化根節點
+        if self._root is None:
+            self._root = TreeNode(num)
+            return
+        # 迴圈查詢，越過葉節點後跳出
+        cur, pre = self._root, None
+        while cur is not None:
+            # 找到重複節點，直接返回
+            if cur.val == num:
+                return
+            pre = cur
+            # 插入位置在 cur 的右子樹中
+            if cur.val < num:
+                cur = cur.right
+            # 插入位置在 cur 的左子樹中
+            else:
+                cur = cur.left
+        # 插入節點
+        node = TreeNode(num)
+        if pre.val < num:
+            pre.right = node
+        else:
+            pre.left = node
+
+    def remove(self, num: int):
+        """刪除節點"""
+        # 若樹為空，直接提前返回
+        if self._root is None:
+            return
+        # 迴圈查詢，越過葉節點後跳出
+        cur, pre = self._root, None
+        while cur is not None:
+            # 找到待刪除節點，跳出迴圈
+            if cur.val == num:
+                break
+            pre = cur
+            # 待刪除節點在 cur 的右子樹中
+            if cur.val < num:
+                cur = cur.right
+            # 待刪除節點在 cur 的左子樹中
+            else:
+                cur = cur.left
+        # 若無待刪除節點，則直接返回
+        if cur is None:
+            return
+
+        # 子節點數量 = 0 or 1
+        if cur.left is None or cur.right is None:
+            # 當子節點數量 = 0 / 1 時， child = null / 該子節點
+            child = cur.left or cur.right
+            # 刪除節點 cur
+            if cur != self._root:
+                if pre.left == cur:
+                    pre.left = child
+                else:
+                    pre.right = child
+            else:
+                # 若刪除節點為根節點，則重新指定根節點
+                self._root = child
+        # 子節點數量 = 2
+        else:
+            # 獲取中序走訪中 cur 的下一個節點
+            tmp: TreeNode = cur.right
+            while tmp.left is not None:
+                tmp = tmp.left
+            # 遞迴刪除節點 tmp
+            self.remove(tmp.val)
+            # 用 tmp 覆蓋 cur
+            cur.val = tmp.val
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    # 初始化二元搜尋樹
+    bst = BinarySearchTree()
+    nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]
+    # 請注意，不同的插入順序會生成不同的二元樹，該序列可以生成一個完美二元樹
+    for num in nums:
+        bst.insert(num)
+    print("\n初始化的二元樹為\n")
+    print_tree(bst.get_root())
+
+    # 查詢節點
+    node = bst.search(7)
+    print("\n查詢到的節點物件為: {}，節點值 = {}".format(node, node.val))
+
+    # 插入節點
+    bst.insert(16)
+    print("\n插入節點 16 後，二元樹為\n")
+    print_tree(bst.get_root())
+
+    # 刪除節點
+    bst.remove(1)
+    print("\n刪除節點 1 後，二元樹為\n")
+    print_tree(bst.get_root())
+
+    bst.remove(2)
+    print("\n刪除節點 2 後，二元樹為\n")
+    print_tree(bst.get_root())
+
+    bst.remove(4)
+    print("\n刪除節點 4 後，二元樹為\n")
+    print_tree(bst.get_root())

zh-hant/codes/python/chapter_tree/binary_tree.py

@@ -0,0 +1,41 @@
+"""
+File: binary_tree.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, print_tree
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    # 初始化二元樹
+    # 初始化節點
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    # 構建節點之間的引用（指標）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    print("\n初始化二元樹\n")
+    print_tree(n1)
+
+    # 插入與刪除節點
+    P = TreeNode(0)
+    # 在 n1 -> n2 中間插入節點 P
+    n1.left = P
+    P.left = n2
+    print("\n插入節點 P 後\n")
+    print_tree(n1)
+    # 刪除節點
+    n1.left = n2
+    print("\n刪除節點 P 後\n")
+    print_tree(n1)

zh-hant/codes/python/chapter_tree/binary_tree_bfs.py

@@ -0,0 +1,42 @@
+"""
+File: binary_tree_bfs.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, list_to_tree, print_tree
+from collections import deque
+
+
+def level_order(root: TreeNode | None) -> list[int]:
+    """層序走訪"""
+    # 初始化佇列，加入根節點
+    queue: deque[TreeNode] = deque()
+    queue.append(root)
+    # 初始化一個串列，用於儲存走訪序列
+    res = []
+    while queue:
+        node: TreeNode = queue.popleft()  # 隊列出隊
+        res.append(node.val)  # 儲存節點值
+        if node.left is not None:
+            queue.append(node.left)  # 左子節點入列
+        if node.right is not None:
+            queue.append(node.right)  # 右子節點入列
+    return res
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    # 初始化二元樹
+    # 這裡藉助了一個從陣列直接生成二元樹的函式
+    root: TreeNode = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
+    print("\n初始化二元樹\n")
+    print_tree(root)
+
+    # 層序走訪
+    res: list[int] = level_order(root)
+    print("\n層序走訪的節點列印序列 = ", res)

zh-hant/codes/python/chapter_tree/binary_tree_dfs.py

@@ -0,0 +1,65 @@
+"""
+File: binary_tree_dfs.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from modules import TreeNode, list_to_tree, print_tree
+
+
+def pre_order(root: TreeNode | None):
+    """前序走訪"""
+    if root is None:
+        return
+    # 訪問優先順序：根節點 -> 左子樹 -> 右子樹
+    res.append(root.val)
+    pre_order(root=root.left)
+    pre_order(root=root.right)
+
+
+def in_order(root: TreeNode | None):
+    """中序走訪"""
+    if root is None:
+        return
+    # 訪問優先順序：左子樹 -> 根節點 -> 右子樹
+    in_order(root=root.left)
+    res.append(root.val)
+    in_order(root=root.right)
+
+
+def post_order(root: TreeNode | None):
+    """後序走訪"""
+    if root is None:
+        return
+    # 訪問優先順序：左子樹 -> 右子樹 -> 根節點
+    post_order(root=root.left)
+    post_order(root=root.right)
+    res.append(root.val)
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    # 初始化二元樹
+    # 這裡藉助了一個從陣列直接生成二元樹的函式
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
+    print("\n初始化二元樹\n")
+    print_tree(root)
+
+    # 前序走訪
+    res = []
+    pre_order(root)
+    print("\n前序走訪的節點列印序列 = ", res)
+
+    # 中序走訪
+    res.clear()
+    in_order(root)
+    print("\n中序走訪的節點列印序列 = ", res)
+
+    # 後序走訪
+    res.clear()
+    post_order(root)
+    print("\n後序走訪的節點列印序列 = ", res)