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-09-01 04:47:12 +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,10 @@
+/*
+ * File: include.rs
+ * Created Time: 2023-02-05
+ * Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICE@outlook.com)
+ */
+
+pub mod print_util;
+pub mod list_node;
+pub mod tree_node;
+pub mod vertex;
@@ -0,0 +1,57 @@
+/*
+ * File: list_node.rs
+ * Created Time: 2023-03-05
+ * Author: codingonion (coderonion@gmail.com), rongyi (hiarongyi@gmail.com)
+ */
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+#[derive(Debug)]
+pub struct ListNode<T> {
+    pub val: T,
+    pub next: Option<Rc<RefCell<ListNode<T>>>>,
+}
+
+impl<T> ListNode<T> {
+    pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {
+        Rc::new(RefCell::new(ListNode { val, next: None }))
+    }
+
+    /* 將陣列反序列化為鏈結串列 */
+    pub fn arr_to_linked_list(array: &[T]) -> Option<Rc<RefCell<ListNode<T>>>>
+    where
+        T: Copy + Clone,
+    {
+        let mut head = None;
+        // insert in reverse order
+        for item in array.iter().rev() {
+            let node = Rc::new(RefCell::new(ListNode {
+                val: *item,
+                next: head.clone(),
+            }));
+            head = Some(node);
+        }
+        head
+    }
+
+    /* 將鏈結串列轉化為雜湊表 */
+    pub fn linked_list_to_hashmap(
+        linked_list: Option<Rc<RefCell<ListNode<T>>>>,
+    ) -> HashMap<T, Rc<RefCell<ListNode<T>>>>
+    where
+        T: std::hash::Hash + Eq + Copy + Clone,
+    {
+        let mut hashmap = HashMap::new();
+        if let Some(node) = linked_list {
+            let mut current = Some(node.clone());
+            while let Some(cur) = current {
+                let borrow = cur.borrow();
+                hashmap.insert(borrow.val.clone(), cur.clone());
+                current = borrow.next.clone();
+            }
+        }
+        hashmap
+    }
+}
@@ -0,0 +1,103 @@
+/*
+ * File: print_util.rs
+ * Created Time: 2023-02-05
+ * Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
+ */
+
+use std::cell::{Cell, RefCell};
+use std::fmt::Display;
+use std::collections::{HashMap, VecDeque};
+use std::rc::Rc;
+
+use crate::list_node::ListNode;
+use crate::tree_node::{TreeNode, vec_to_tree};
+
+struct Trunk<'a, 'b> {
+    prev: Option<&'a Trunk<'a, 'b>>,
+    str: Cell<&'b str>,
+}
+
+/* 列印陣列 */
+pub fn print_array<T: Display>(nums: &[T]) {
+    print!("[");
+    if nums.len() > 0 {
+        for (i, num) in nums.iter().enumerate() {
+            print!("{}{}", num, if i == nums.len() - 1 {"]"} else {", "} );
+        }
+    } else {
+        print!("]");
+    }
+}
+
+/* 列印雜湊表 */
+pub fn print_hash_map<TKey: Display, TValue: Display>(map: &HashMap<TKey, TValue>) {
+    for (key, value) in map {
+        println!("{key} -> {value}");
+    }
+}
+
+/* 列印佇列（雙向佇列） */
+pub fn print_queue<T: Display>(queue: &VecDeque<T>) {
+    print!("[");
+    let iter = queue.iter();
+    for (i, data) in iter.enumerate() {
+        print!("{}{}", data, if i == queue.len() - 1 {"]"} else {", "} );
+    }
+}
+
+/* 列印鏈結串列 */
+pub fn print_linked_list<T: Display>(head: &Rc<RefCell<ListNode<T>>>) {
+    print!("{}{}", head.borrow().val, if head.borrow().next.is_none() {"\n"} else {" -> "});
+    if let Some(node) = &head.borrow().next {
+        return print_linked_list(node);
+    }
+}
+
+/* 列印二元樹 */
+pub fn print_tree(root: &Rc<RefCell<TreeNode>>) {
+    _print_tree(Some(root), None, false);
+}
+
+/* 列印二元樹 */
+fn _print_tree(root: Option<&Rc<RefCell<TreeNode>>>, prev: Option<&Trunk>, is_right: bool) {
+    if let Some(node) = root {
+        let mut prev_str = "    ";
+        let trunk = Trunk { prev, str: Cell::new(prev_str) };
+        _print_tree(node.borrow().right.as_ref(), Some(&trunk), true);
+
+        if  prev.is_none() {
+            trunk.str.set("———");
+        } else if is_right {
+            trunk.str.set("/———");
+            prev_str = "   |";
+        } else {
+            trunk.str.set("\\———");
+            prev.as_ref().unwrap().str.set(prev_str);
+        }
+
+        show_trunks(Some(&trunk));
+        println!(" {}", node.borrow().val);
+        if let Some(prev) = prev {
+            prev.str.set(prev_str);
+        }
+        trunk.str.set("   |");
+
+        _print_tree(node.borrow().left.as_ref(), Some(&trunk), false);
+    }
+}
+
+fn show_trunks(trunk: Option<&Trunk>) {
+    if let Some(trunk) = trunk {
+        show_trunks(trunk.prev);
+        print!("{}", trunk.str.get());
+    }
+}
+
+/* 列印堆積 */
+pub fn print_heap(heap: Vec<i32>) {
+    println!("堆積的陣列表示：{:?}", heap);
+    println!("堆積的樹狀表示：");
+    if let Some(root) = vec_to_tree(heap.into_iter().map(|val| Some(val)).collect()) {
+        print_tree(&root);
+    } 
+}
@@ -0,0 +1,93 @@
+/*
+ * File: tree_node.rs
+ * Created Time: 2023-02-27
+ * Author: xBLACKICEx (xBLACKICE@outlook.com), night-cruise (2586447362@qq.com)
+ */
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/* 二元樹節點型別 */
+#[derive(Debug)]
+pub struct TreeNode {
+    pub val: i32,
+    pub height: i32,
+    pub parent: Option<Rc<RefCell<TreeNode>>>,
+    pub left: Option<Rc<RefCell<TreeNode>>>,
+    pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+    /* 建構子 */
+    pub fn new(val: i32) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self {
+            val,
+            height: 0,
+            parent: None,
+            left: None,
+            right: None
+        }))
+    }
+}
+
+#[macro_export]
+macro_rules! op_vec {
+    ( $( $x:expr ),* ) => {
+        vec![
+            $( Option::from($x).map(|x| x) ),* 
+        ]
+    };
+}
+
+// 序列化編碼規則請參考：
+// https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
+// 二元樹的陣列表示：
+// [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+// 二元樹的鏈結串列表示：
+//             /——— 15
+//         /——— 7
+//     /——— 3
+//    |    \——— 6
+//    |        \——— 12
+// ——— 1
+//     \——— 2
+//        |    /——— 9
+//         \——— 4
+//             \——— 8
+
+/* 將串列反序列化為二元樹：遞迴 */
+fn vec_to_tree_dfs(arr: &[Option<i32>], i: usize) -> Option<Rc<RefCell<TreeNode>>> {
+    if i >= arr.len() || arr[i].is_none() {
+        return None;
+    }
+    let root = TreeNode::new(arr[i].unwrap());
+    root.borrow_mut().left = vec_to_tree_dfs(arr, 2 * i + 1);
+    root.borrow_mut().right = vec_to_tree_dfs(arr, 2 * i + 2);
+    Some(root)
+}
+
+/* 將串列反序列化為二元樹 */
+pub fn vec_to_tree(arr: Vec<Option<i32>>) -> Option<Rc<RefCell<TreeNode>>> {
+    vec_to_tree_dfs(&arr, 0)
+}
+
+/* 將二元樹序列化為串列：遞迴 */
+fn tree_to_vec_dfs(root: Option<Rc<RefCell<TreeNode>>>, i: usize, res: &mut Vec<Option<i32>>) {
+    if root.is_none() {
+        return;
+    }    
+    let root = root.unwrap();
+    while i >= res.len() {
+        res.push(None);
+    }
+    res[i] = Some(root.borrow().val);
+    tree_to_vec_dfs(root.borrow().left.clone(), 2 * i + 1, res);
+    tree_to_vec_dfs(root.borrow().right.clone(), 2 * i + 2, res);
+}
+
+/* 將二元樹序列化為串列 */
+pub fn tree_to_vec(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Option<i32>> {
+    let mut res = vec![];
+    tree_to_vec_dfs(root, 0, &mut res);
+    res
+}
@@ -0,0 +1,21 @@
+/*
+ * File: vertex.rs
+ * Created Time: 2023-07-13
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+/* 頂點型別 */
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Vertex {
+    pub val: i32
+}
+
+/* 輸入值串列 vals ，返回頂點串列 vets */
+pub fn vals_to_vets(vals: Vec<i32>) -> Vec<Vertex> {
+    vals.into_iter().map(|val| Vertex { val }).collect()
+}
+
+/* 輸入頂點串列 vets ，返回值串列 vals */
+pub fn vets_to_vals(vets: Vec<Vertex>) -> Vec<i32> {
+    vets.into_iter().map(|vet| vet.val).collect()
+}