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-16 13:40: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,111 @@
+/*
+ * File: array.rs
+ * Created Time: 2023-01-15
+ * Author: xBLACICEx (xBLACKICEx@outlook.com), codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use rand::Rng;
+
+/* 隨機訪問元素 */
+fn random_access(nums: &[i32]) -> i32 {
+    // 在區間 [0, nums.len()) 中隨機抽取一個數字
+    let random_index = rand::thread_rng().gen_range(0..nums.len());
+    // 獲取並返回隨機元素
+    let random_num = nums[random_index];
+    random_num
+}
+
+/* 擴展陣列長度 */
+fn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {
+    // 初始化一個擴展長度後的陣列
+    let mut res: Vec<i32> = vec![0; nums.len() + enlarge];
+    // 將原陣列中的所有元素複製到新
+    for i in 0..nums.len() {
+        res[i] = nums[i];
+    }
+    // 返回擴展後的新陣列
+    res
+}
+
+/* 在陣列的索引 index 處插入元素 num */
+fn insert(nums: &mut Vec<i32>, num: i32, index: usize) {
+    // 把索引 index 以及之後的所有元素向後移動一位
+    for i in (index + 1..nums.len()).rev() {
+        nums[i] = nums[i - 1];
+    }
+    // 將 num 賦給 index 處的元素
+    nums[index] = num;
+}
+
+/* 刪除索引 index 處的元素 */
+fn remove(nums: &mut Vec<i32>, index: usize) {
+    // 把索引 index 之後的所有元素向前移動一位
+    for i in index..nums.len() - 1 {
+        nums[i] = nums[i + 1];
+    }
+}
+
+/* 走訪陣列 */
+fn traverse(nums: &[i32]) {
+    let mut _count = 0;
+    // 透過索引走訪陣列
+    for i in 0..nums.len() {
+        _count += nums[i];
+    }
+    // 直接走訪陣列元素
+    for num in nums {
+        _count += num;
+    }
+}
+
+/* 在陣列中查詢指定元素 */
+fn find(nums: &[i32], target: i32) -> Option<usize> {
+    for i in 0..nums.len() {
+        if nums[i] == target {
+            return Some(i);
+        }
+    }
+    None
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化陣列 */
+    let arr = [0; 5];
+    print!("陣列 arr = ");
+    print_util::print_array(&arr);
+    // 在 Rust 中，指定長度時（[i32; 5]）為陣列
+    // 由於 Rust 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度
+    // 為了方便實現擴容 extend() 方法，以下將(Vec) 看作陣列（Array）也是rust一般情況下使用動態陣列的型別
+    let nums = vec![1, 3, 2, 5, 4];
+    print!("\n陣列 nums = ");
+    print_util::print_array(&nums);
+
+    // 隨機訪問
+    let random_num = random_access(&nums);
+    println!("\n在 nums 中獲取隨機元素 {}", random_num);
+
+    // 長度擴展
+    let mut nums = extend(nums, 3);
+    print!("將陣列長度擴展至 8 ，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 插入元素
+    insert(&mut nums, 6, 3);
+    print!("\n在索引 3 處插入數字 6 ，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 刪除元素
+    remove(&mut nums, 2);
+    print!("\n刪除索引 2 處的元素，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 走訪陣列
+    traverse(&nums);
+
+    // 查詢元素
+    let index = find(&nums, 3).unwrap();
+    println!("\n在 nums 中查詢元素 3 ，得到索引 = {}", index);
+}
@@ -0,0 +1,92 @@
+/*
+ * File: linked_list.rs
+ * Created Time: 2023-03-05
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use list_node::ListNode;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/* 在鏈結串列的節點 n0 之後插入節點 P */
+#[allow(non_snake_case)]
+pub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {
+    let n1 = n0.borrow_mut().next.take();
+    P.borrow_mut().next = n1;
+    n0.borrow_mut().next = Some(P);
+}
+
+/* 刪除鏈結串列的節點 n0 之後的首個節點 */
+#[allow(non_snake_case)]
+pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
+    if n0.borrow().next.is_none() {
+        return;
+    };
+    // n0 -> P -> n1
+    let P = n0.borrow_mut().next.take();
+    if let Some(node) = P {
+        let n1 = node.borrow_mut().next.take();
+        n0.borrow_mut().next = n1;
+    }
+}
+
+/* 訪問鏈結串列中索引為 index 的節點 */
+pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {
+    if index <= 0 {
+        return head;
+    };
+    if let Some(node) = &head.borrow().next {
+        return access(node.clone(), index - 1);
+    }
+
+    return head;
+}
+
+/* 在鏈結串列中查詢值為 target 的首個節點 */
+pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {
+    if head.borrow().val == target {
+        return index;
+    };
+    if let Some(node) = &head.borrow_mut().next {
+        return find(node.clone(), target, index + 1);
+    }
+    return -1;
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化鏈結串列 */
+    // 初始化各個節點
+    let n0 = ListNode::new(1);
+    let n1 = ListNode::new(3);
+    let n2 = ListNode::new(2);
+    let n3 = ListNode::new(5);
+    let n4 = ListNode::new(4);
+    // 構建節點之間的引用
+    n0.borrow_mut().next = Some(n1.clone());
+    n1.borrow_mut().next = Some(n2.clone());
+    n2.borrow_mut().next = Some(n3.clone());
+    n3.borrow_mut().next = Some(n4.clone());
+    print!("初始化的鏈結串列為 ");
+    print_util::print_linked_list(&n0);
+
+    /* 插入節點 */
+    insert(&n0, ListNode::new(0));
+    print!("插入節點後的鏈結串列為 ");
+    print_util::print_linked_list(&n0);
+
+    /* 刪除節點 */
+    remove(&n0);
+    print!("刪除節點後的鏈結串列為 ");
+    print_util::print_linked_list(&n0);
+
+    /* 訪問節點 */
+    let node = access(n0.clone(), 3);
+    println!("鏈結串列中索引 3 處的節點的值 = {}", node.borrow().val);
+
+    /* 查詢節點 */
+    let index = find(n0.clone(), 2, 0);
+    println!("鏈結串列中值為 2 的節點的索引 = {}", index);
+}
@@ -0,0 +1,72 @@
+/*
+ * File: list.rs
+ * Created Time: 2023-01-18
+ * Author: xBLACICEx (xBLACKICEx@outlook.com), codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+/* Driver Code */
+fn main() {
+    // 初始化串列
+    let mut nums: Vec<i32> = vec![1, 3, 2, 5, 4];
+    print!("串列 nums = ");
+    print_util::print_array(&nums);
+
+    // 訪問元素
+    let num = nums[1];
+    println!("\n訪問索引 1 處的元素，得到 num = {num}");
+
+    // 更新元素
+    nums[1] = 0;
+    print!("將索引 1 處的元素更新為 0 ，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 清空串列
+    nums.clear();
+    print!("\n清空串列後 nums = ");
+    print_util::print_array(&nums);
+
+    // 在尾部新增元素
+    nums.push(1);
+    nums.push(3);
+    nums.push(2);
+    nums.push(5);
+    nums.push(4);
+    print!("\n新增元素後 nums = ");
+    print_util::print_array(&nums);
+
+    // 在中間插入元素
+    nums.insert(3, 6);
+    print!("\n在索引 3 處插入數字 6 ，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 刪除元素
+    nums.remove(3);
+    print!("\n刪除索引 3 處的元素，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 透過索引走訪串列
+    let mut _count = 0;
+    for i in 0..nums.len() {
+        _count += nums[i];
+    }
+    // 直接走訪串列元素
+    _count = 0;
+    for x in &nums {
+        _count += x;
+    }
+
+    // 拼接兩個串列
+    let mut nums1 = vec![6, 8, 7, 10, 9];
+    nums.append(&mut nums1); // append（移動） 之後 nums1 為空！
+
+    // nums.extend(&nums1);   // extend（借用） nums1 能繼續使用
+    print!("\n將串列 nums1 拼接到 nums 之後，得到 nums = ");
+    print_util::print_array(&nums);
+
+    // 排序串列
+    nums.sort();
+    print!("\n排序串列後 nums = ");
+    print_util::print_array(&nums);
+}
@@ -0,0 +1,165 @@
+/*
+ * File: my_list.rs
+ * Created Time: 2023-03-11
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+/* 串列類別 */
+#[allow(dead_code)]
+struct MyList {
+    arr: Vec<i32>,       // 陣列（儲存串列元素）
+    capacity: usize,     // 串列容量
+    size: usize,         // 串列長度（當前元素數量）
+    extend_ratio: usize, // 每次串列擴容的倍數
+}
+
+#[allow(unused, unused_comparisons)]
+impl MyList {
+    /* 建構子 */
+    pub fn new(capacity: usize) -> Self {
+        let mut vec = Vec::new();
+        vec.resize(capacity, 0);
+        Self {
+            arr: vec,
+            capacity,
+            size: 0,
+            extend_ratio: 2,
+        }
+    }
+
+    /* 獲取串列長度（當前元素數量）*/
+    pub fn size(&self) -> usize {
+        return self.size;
+    }
+
+    /* 獲取串列容量 */
+    pub fn capacity(&self) -> usize {
+        return self.capacity;
+    }
+
+    /* 訪問元素 */
+    pub fn get(&self, index: usize) -> i32 {
+        // 索引如果越界，則丟擲異常，下同
+        if index >= self.size {
+            panic!("索引越界")
+        };
+        return self.arr[index];
+    }
+
+    /* 更新元素 */
+    pub fn set(&mut self, index: usize, num: i32) {
+        if index >= self.size {
+            panic!("索引越界")
+        };
+        self.arr[index] = num;
+    }
+
+    /* 在尾部新增元素 */
+    pub fn add(&mut self, num: i32) {
+        // 元素數量超出容量時，觸發擴容機制
+        if self.size == self.capacity() {
+            self.extend_capacity();
+        }
+        self.arr[self.size] = num;
+        // 更新元素數量
+        self.size += 1;
+    }
+
+    /* 在中間插入元素 */
+    pub fn insert(&mut self, index: usize, num: i32) {
+        if index >= self.size() {
+            panic!("索引越界")
+        };
+        // 元素數量超出容量時，觸發擴容機制
+        if self.size == self.capacity() {
+            self.extend_capacity();
+        }
+        // 將索引 index 以及之後的元素都向後移動一位
+        for j in (index..self.size).rev() {
+            self.arr[j + 1] = self.arr[j];
+        }
+        self.arr[index] = num;
+        // 更新元素數量
+        self.size += 1;
+    }
+
+    /* 刪除元素 */
+    pub fn remove(&mut self, index: usize) -> i32 {
+        if index >= self.size() {
+            panic!("索引越界")
+        };
+        let num = self.arr[index];
+        // 將將索引 index 之後的元素都向前移動一位
+        for j in (index..self.size - 1) {
+            self.arr[j] = self.arr[j + 1];
+        }
+        // 更新元素數量
+        self.size -= 1;
+        // 返回被刪除的元素
+        return num;
+    }
+
+    /* 串列擴容 */
+    pub fn extend_capacity(&mut self) {
+        // 新建一個長度為原陣列 extend_ratio 倍的新陣列，並將原陣列複製到新陣列
+        let new_capacity = self.capacity * self.extend_ratio;
+        self.arr.resize(new_capacity, 0);
+        // 更新串列容量
+        self.capacity = new_capacity;
+    }
+
+    /* 將串列轉換為陣列 */
+    pub fn to_array(&mut self) -> Vec<i32> {
+        // 僅轉換有效長度範圍內的串列元素
+        let mut arr = Vec::new();
+        for i in 0..self.size {
+            arr.push(self.get(i));
+        }
+        arr
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化串列 */
+    let mut nums = MyList::new(10);
+    /* 在尾部新增元素 */
+    nums.add(1);
+    nums.add(3);
+    nums.add(2);
+    nums.add(5);
+    nums.add(4);
+    print!("串列 nums = ");
+    print_util::print_array(&nums.to_array());
+    print!(" ，容量 = {} ，長度 = {}", nums.capacity(), nums.size());
+
+    /* 在中間插入元素 */
+    nums.insert(3, 6);
+    print!("\n在索引 3 處插入數字 6 ，得到 nums = ");
+    print_util::print_array(&nums.to_array());
+
+    /* 刪除元素 */
+    nums.remove(3);
+    print!("\n刪除索引 3 處的元素，得到 nums = ");
+    print_util::print_array(&nums.to_array());
+
+    /* 訪問元素 */
+    let num = nums.get(1);
+    println!("\n訪問索引 1 處的元素，得到 num = {num}");
+
+    /* 更新元素 */
+    nums.set(1, 0);
+    print!("將索引 1 處的元素更新為 0 ，得到 nums = ");
+    print_util::print_array(&nums.to_array());
+
+    /* 測試擴容機制 */
+    for i in 0..10 {
+        // 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
+        nums.add(i);
+    }
+    print!("\n擴容後的串列 nums = ");
+    print_util::print_array(&nums.to_array());
+    print!(" ，容量 = {} ，長度 = {}", nums.capacity(), nums.size());
+}