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-03 21:57:14 +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,199 @@
+/*
+ * File: array_binary_tree.rs
+ * Created Time: 2023-07-25
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+include!("../include/include.rs");
+
+/* 陣列表示下的二元樹類別 */
+struct ArrayBinaryTree {
+    tree: Vec<Option<i32>>,
+}
+
+impl ArrayBinaryTree {
+    /* 建構子 */
+    fn new(arr: Vec<Option<i32>>) -> Self {
+        Self { tree: arr }
+    }
+
+    /* 串列容量 */
+    fn size(&self) -> i32 {
+        self.tree.len() as i32
+    }
+
+    /* 獲取索引為 i 節點的值 */
+    fn val(&self, i: i32) -> Option<i32> {
+        // 若索引越界，則返回 None ，代表空位
+        if i < 0 || i >= self.size() {
+            None
+        } else {
+            self.tree[i as usize]
+        }
+    }
+
+    /* 獲取索引為 i 節點的左子節點的索引 */
+    fn left(&self, i: i32) -> i32 {
+        2 * i + 1
+    }
+
+    /* 獲取索引為 i 節點的右子節點的索引 */
+    fn right(&self, i: i32) -> i32 {
+        2 * i + 2
+    }
+
+    /* 獲取索引為 i 節點的父節點的索引 */
+    fn parent(&self, i: i32) -> i32 {
+        (i - 1) / 2
+    }
+
+    /* 層序走訪 */
+    fn level_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        // 直接走訪陣列
+        for i in 0..self.size() {
+            if let Some(val) = self.val(i) {
+                res.push(val)
+            }
+        }
+        res
+    }
+
+    /* 深度優先走訪 */
+    fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {
+        if self.val(i).is_none() {
+            return;
+        }
+        let val = self.val(i).unwrap();
+        // 前序走訪
+        if order == "pre" {
+            res.push(val);
+        }
+        self.dfs(self.left(i), order, res);
+        // 中序走訪
+        if order == "in" {
+            res.push(val);
+        }
+        self.dfs(self.right(i), order, res);
+        // 後序走訪
+        if order == "post" {
+            res.push(val);
+        }
+    }
+
+    /* 前序走訪 */
+    fn pre_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "pre", &mut res);
+        res
+    }
+
+    /* 中序走訪 */
+    fn in_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "in", &mut res);
+        res
+    }
+
+    /* 後序走訪 */
+    fn post_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "post", &mut res);
+        res
+    }
+}
+
+/* Driver Code */
+fn main() {
+    // 初始化二元樹
+    // 這裡藉助了一個從陣列直接生成二元樹的函式
+    let arr = vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        None,
+        Some(6),
+        Some(7),
+        Some(8),
+        Some(9),
+        None,
+        None,
+        Some(12),
+        None,
+        None,
+        Some(15),
+    ];
+
+    let root = tree_node::vec_to_tree(arr.clone()).unwrap();
+    println!("\n初始化二元樹\n");
+    println!("二元樹的陣列表示：");
+    println!(
+        "[{}]",
+        arr.iter()
+            .map(|&val| if let Some(val) = val {
+                format!("{val}")
+            } else {
+                "null".to_string()
+            })
+            .collect::<Vec<String>>()
+            .join(", ")
+    );
+    println!("二元樹的鏈結串列表示：");
+    print_util::print_tree(&root);
+
+    // 陣列表示下的二元樹類別
+    let abt = ArrayBinaryTree::new(arr);
+
+    // 訪問節點
+    let i = 1;
+    let l = abt.left(i);
+    let r = abt.right(i);
+    let p = abt.parent(i);
+    println!(
+        "\n當前節點的索引為 {} ，值為 {}",
+        i,
+        if let Some(val) = abt.val(i) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+    println!(
+        "其左子節點的索引為 {} ，值為 {}",
+        l,
+        if let Some(val) = abt.val(l) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+    println!(
+        "其右子節點的索引為 {} ，值為 {}",
+        r,
+        if let Some(val) = abt.val(r) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+    println!(
+        "其父節點的索引為 {} ，值為 {}",
+        p,
+        if let Some(val) = abt.val(p) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+
+    // 走訪樹
+    let mut res = abt.level_order();
+    println!("\n層序走訪為：{:?}", res);
+    res = abt.pre_order();
+    println!("前序走訪為：{:?}", res);
+    res = abt.in_order();
+    println!("中序走訪為：{:?}", res);
+    res = abt.post_order();
+    println!("後序走訪為：{:?}", res);
+}
@@ -0,0 +1,298 @@
+/*
+ * File: avl_tree.rs
+ * Created Time: 2023-07-14
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+include!("../include/include.rs");
+
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::rc::Rc;
+use tree_node::TreeNode;
+
+type OptionTreeNodeRc = Option<Rc<RefCell<TreeNode>>>;
+
+/* AVL 樹 */
+struct AVLTree {
+    root: OptionTreeNodeRc, // 根節點
+}
+
+impl AVLTree {
+    /* 建構子 */
+    fn new() -> Self {
+        Self { root: None }
+    }
+
+    /* 獲取節點高度 */
+    fn height(node: OptionTreeNodeRc) -> i32 {
+        // 空節點高度為 -1 ，葉節點高度為 0
+        match node {
+            Some(node) => node.borrow().height,
+            None => -1,
+        }
+    }
+
+    /* 更新節點高度 */
+    fn update_height(node: OptionTreeNodeRc) {
+        if let Some(node) = node {
+            let left = node.borrow().left.clone();
+            let right = node.borrow().right.clone();
+            // 節點高度等於最高子樹高度 + 1
+            node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;
+        }
+    }
+
+    /* 獲取平衡因子 */
+    fn balance_factor(node: OptionTreeNodeRc) -> i32 {
+        match node {
+            // 空節點平衡因子為 0
+            None => 0,
+            // 節點平衡因子 = 左子樹高度 - 右子樹高度
+            Some(node) => {
+                Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())
+            }
+        }
+    }
+
+    /* 右旋操作 */
+    fn right_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+        match node {
+            Some(node) => {
+                let child = node.borrow().left.clone().unwrap();
+                let grand_child = child.borrow().right.clone();
+                // 以 child 為原點，將 node 向右旋轉
+                child.borrow_mut().right = Some(node.clone());
+                node.borrow_mut().left = grand_child;
+                // 更新節點高度
+                Self::update_height(Some(node));
+                Self::update_height(Some(child.clone()));
+                // 返回旋轉後子樹的根節點
+                Some(child)
+            }
+            None => None,
+        }
+    }
+
+    /* 左旋操作 */
+    fn left_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+        match node {
+            Some(node) => {
+                let child = node.borrow().right.clone().unwrap();
+                let grand_child = child.borrow().left.clone();
+                // 以 child 為原點，將 node 向左旋轉
+                child.borrow_mut().left = Some(node.clone());
+                node.borrow_mut().right = grand_child;
+                // 更新節點高度
+                Self::update_height(Some(node));
+                Self::update_height(Some(child.clone()));
+                // 返回旋轉後子樹的根節點
+                Some(child)
+            }
+            None => None,
+        }
+    }
+
+    /* 執行旋轉操作，使該子樹重新恢復平衡 */
+    fn rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+        // 獲取節點 node 的平衡因子
+        let balance_factor = Self::balance_factor(node.clone());
+        // 左偏樹
+        if balance_factor > 1 {
+            let node = node.unwrap();
+            if Self::balance_factor(node.borrow().left.clone()) >= 0 {
+                // 右旋
+                Self::right_rotate(Some(node))
+            } else {
+                // 先左旋後右旋
+                let left = node.borrow().left.clone();
+                node.borrow_mut().left = Self::left_rotate(left);
+                Self::right_rotate(Some(node))
+            }
+        }
+        // 右偏樹
+        else if balance_factor < -1 {
+            let node = node.unwrap();
+            if Self::balance_factor(node.borrow().right.clone()) <= 0 {
+                // 左旋
+                Self::left_rotate(Some(node))
+            } else {
+                // 先右旋後左旋
+                let right = node.borrow().right.clone();
+                node.borrow_mut().right = Self::right_rotate(right);
+                Self::left_rotate(Some(node))
+            }
+        } else {
+            // 平衡樹，無須旋轉，直接返回
+            node
+        }
+    }
+
+    /* 插入節點 */
+    fn insert(&mut self, val: i32) {
+        self.root = Self::insert_helper(self.root.clone(), val);
+    }
+
+    /* 遞迴插入節點（輔助方法） */
+    fn insert_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {
+        match node {
+            Some(mut node) => {
+                /* 1. 查詢插入位置並插入節點 */
+                match {
+                    let node_val = node.borrow().val;
+                    node_val
+                }
+                .cmp(&val)
+                {
+                    Ordering::Greater => {
+                        let left = node.borrow().left.clone();
+                        node.borrow_mut().left = Self::insert_helper(left, val);
+                    }
+                    Ordering::Less => {
+                        let right = node.borrow().right.clone();
+                        node.borrow_mut().right = Self::insert_helper(right, val);
+                    }
+                    Ordering::Equal => {
+                        return Some(node); // 重複節點不插入，直接返回
+                    }
+                }
+                Self::update_height(Some(node.clone())); // 更新節點高度
+
+                /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */
+                node = Self::rotate(Some(node)).unwrap();
+                // 返回子樹的根節點
+                Some(node)
+            }
+            None => Some(TreeNode::new(val)),
+        }
+    }
+
+    /* 刪除節點 */
+    fn remove(&self, val: i32) {
+        Self::remove_helper(self.root.clone(), val);
+    }
+
+    /* 遞迴刪除節點（輔助方法） */
+    fn remove_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {
+        match node {
+            Some(mut node) => {
+                /* 1. 查詢節點並刪除 */
+                if val < node.borrow().val {
+                    let left = node.borrow().left.clone();
+                    node.borrow_mut().left = Self::remove_helper(left, val);
+                } else if val > node.borrow().val {
+                    let right = node.borrow().right.clone();
+                    node.borrow_mut().right = Self::remove_helper(right, val);
+                } else if node.borrow().left.is_none() || node.borrow().right.is_none() {
+                    let child = if node.borrow().left.is_some() {
+                        node.borrow().left.clone()
+                    } else {
+                        node.borrow().right.clone()
+                    };
+                    match child {
+                        // 子節點數量 = 0 ，直接刪除 node 並返回
+                        None => {
+                            return None;
+                        }
+                        // 子節點數量 = 1 ，直接刪除 node
+                        Some(child) => node = child,
+                    }
+                } else {
+                    // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點
+                    let mut temp = node.borrow().right.clone().unwrap();
+                    loop {
+                        let temp_left = temp.borrow().left.clone();
+                        if temp_left.is_none() {
+                            break;
+                        }
+                        temp = temp_left.unwrap();
+                    }
+                    let right = node.borrow().right.clone();
+                    node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);
+                    node.borrow_mut().val = temp.borrow().val;
+                }
+                Self::update_height(Some(node.clone())); // 更新節點高度
+
+                /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */
+                node = Self::rotate(Some(node)).unwrap();
+                // 返回子樹的根節點
+                Some(node)
+            }
+            None => None,
+        }
+    }
+
+    /* 查詢節點 */
+    fn search(&self, val: i32) -> OptionTreeNodeRc {
+        let mut cur = self.root.clone();
+        // 迴圈查詢，越過葉節點後跳出
+        while let Some(current) = cur.clone() {
+            match current.borrow().val.cmp(&val) {
+                // 目標節點在 cur 的右子樹中
+                Ordering::Less => {
+                    cur = current.borrow().right.clone();
+                }
+                // 目標節點在 cur 的左子樹中
+                Ordering::Greater => {
+                    cur = current.borrow().left.clone();
+                }
+                // 找到目標節點，跳出迴圈
+                Ordering::Equal => {
+                    break;
+                }
+            }
+        }
+        // 返回目標節點
+        cur
+    }
+}
+
+/* Driver Code */
+fn main() {
+    fn test_insert(tree: &mut AVLTree, val: i32) {
+        tree.insert(val);
+        println!("\n插入節點 {} 後，AVL 樹為", val);
+        print_util::print_tree(&tree.root.clone().unwrap());
+    }
+
+    fn test_remove(tree: &mut AVLTree, val: i32) {
+        tree.remove(val);
+        println!("\n刪除節點 {} 後，AVL 樹為", val);
+        print_util::print_tree(&tree.root.clone().unwrap());
+    }
+
+    /* 初始化空 AVL 樹 */
+    let mut avl_tree = AVLTree::new();
+
+    /* 插入節點 */
+    // 請關注插入節點後，AVL 樹是如何保持平衡的
+    test_insert(&mut avl_tree, 1);
+    test_insert(&mut avl_tree, 2);
+    test_insert(&mut avl_tree, 3);
+    test_insert(&mut avl_tree, 4);
+    test_insert(&mut avl_tree, 5);
+    test_insert(&mut avl_tree, 8);
+    test_insert(&mut avl_tree, 7);
+    test_insert(&mut avl_tree, 9);
+    test_insert(&mut avl_tree, 10);
+    test_insert(&mut avl_tree, 6);
+
+    /* 插入重複節點 */
+    test_insert(&mut avl_tree, 7);
+
+    /* 刪除節點 */
+    // 請關注刪除節點後，AVL 樹是如何保持平衡的
+    test_remove(&mut avl_tree, 8); // 刪除度為 0 的節點
+    test_remove(&mut avl_tree, 5); // 刪除度為 1 的節點
+    test_remove(&mut avl_tree, 4); // 刪除度為 2 的節點
+
+    /* 查詢節點 */
+    let node = avl_tree.search(7);
+    if let Some(node) = node {
+        println!(
+            "\n查詢到的節點物件為 {:?}，節點值 = {}",
+            &*node.borrow(),
+            node.borrow().val
+        );
+    }
+}
@@ -0,0 +1,195 @@
+/*
+ * File: binary_search_tree.rs
+ * Created Time: 2023-04-20
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)、night-cruise (2586447362@qq.com)
+ */
+
+include!("../include/include.rs");
+
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::rc::Rc;
+
+use tree_node::TreeNode;
+
+type OptionTreeNodeRc = Option<Rc<RefCell<TreeNode>>>;
+
+/* 二元搜尋樹 */
+pub struct BinarySearchTree {
+    root: OptionTreeNodeRc,
+}
+
+impl BinarySearchTree {
+    /* 建構子 */
+    pub fn new() -> Self {
+        // 初始化空樹
+        Self { root: None }
+    }
+
+    /* 獲取二元樹根節點 */
+    pub fn get_root(&self) -> OptionTreeNodeRc {
+        self.root.clone()
+    }
+
+    /* 查詢節點 */
+    pub fn search(&self, num: i32) -> OptionTreeNodeRc {
+        let mut cur = self.root.clone();
+        // 迴圈查詢，越過葉節點後跳出
+        while let Some(node) = cur.clone() {
+            match num.cmp(&node.borrow().val) {
+                // 目標節點在 cur 的右子樹中
+                Ordering::Greater => cur = node.borrow().right.clone(),
+                // 目標節點在 cur 的左子樹中
+                Ordering::Less => cur = node.borrow().left.clone(),
+                // 找到目標節點，跳出迴圈
+                Ordering::Equal => break,
+            }
+        }
+
+        // 返回目標節點
+        cur
+    }
+
+    /* 插入節點 */
+    pub fn insert(&mut self, num: i32) {
+        // 若樹為空，則初始化根節點
+        if self.root.is_none() {
+            self.root = Some(TreeNode::new(num));
+            return;
+        }
+        let mut cur = self.root.clone();
+        let mut pre = None;
+        // 迴圈查詢，越過葉節點後跳出
+        while let Some(node) = cur.clone() {
+            match num.cmp(&node.borrow().val) {
+                // 找到重複節點，直接返回
+                Ordering::Equal => return,
+                // 插入位置在 cur 的右子樹中
+                Ordering::Greater => {
+                    pre = cur.clone();
+                    cur = node.borrow().right.clone();
+                }
+                // 插入位置在 cur 的左子樹中
+                Ordering::Less => {
+                    pre = cur.clone();
+                    cur = node.borrow().left.clone();
+                }
+            }
+        }
+        // 插入節點
+        let pre = pre.unwrap();
+        let node = Some(TreeNode::new(num));
+        if num > pre.borrow().val {
+            pre.borrow_mut().right = node;
+        } else {
+            pre.borrow_mut().left = node;
+        }
+    }
+
+    /* 刪除節點 */
+    pub fn remove(&mut self, num: i32) {
+        // 若樹為空，直接提前返回
+        if self.root.is_none() {
+            return;
+        }
+        let mut cur = self.root.clone();
+        let mut pre = None;
+        // 迴圈查詢，越過葉節點後跳出
+        while let Some(node) = cur.clone() {
+            match num.cmp(&node.borrow().val) {
+                // 找到待刪除節點，跳出迴圈
+                Ordering::Equal => break,
+                // 待刪除節點在 cur 的右子樹中
+                Ordering::Greater => {
+                    pre = cur.clone();
+                    cur = node.borrow().right.clone();
+                }
+                // 待刪除節點在 cur 的左子樹中
+                Ordering::Less => {
+                    pre = cur.clone();
+                    cur = node.borrow().left.clone();
+                }
+            }
+        }
+        // 若無待刪除節點，則直接返回
+        if cur.is_none() {
+            return;
+        }
+        let cur = cur.unwrap();
+        let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());
+        match (left_child.clone(), right_child.clone()) {
+            // 子節點數量 = 0 or 1
+            (None, None) | (Some(_), None) | (None, Some(_)) => {
+                // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點
+                let child = left_child.or(right_child);
+                let pre = pre.unwrap();
+                // 刪除節點 cur
+                if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {
+                    let left = pre.borrow().left.clone();
+                    if left.is_some() && Rc::ptr_eq(&left.as_ref().unwrap(), &cur) {
+                        pre.borrow_mut().left = child;
+                    } else {
+                        pre.borrow_mut().right = child;
+                    }
+                } else {
+                    // 若刪除節點為根節點，則重新指定根節點
+                    self.root = child;
+                }
+            }
+            // 子節點數量 = 2
+            (Some(_), Some(_)) => {
+                // 獲取中序走訪中 cur 的下一個節點
+                let mut tmp = cur.borrow().right.clone();
+                while let Some(node) = tmp.clone() {
+                    if node.borrow().left.is_some() {
+                        tmp = node.borrow().left.clone();
+                    } else {
+                        break;
+                    }
+                }
+                let tmpval = tmp.unwrap().borrow().val;
+                // 遞迴刪除節點 tmp
+                self.remove(tmpval);
+                // 用 tmp 覆蓋 cur
+                cur.borrow_mut().val = tmpval;
+            }
+        }
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化二元搜尋樹 */
+    let mut bst = BinarySearchTree::new();
+    // 請注意，不同的插入順序會生成不同的二元樹，該序列可以生成一個完美二元樹
+    let nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
+    for &num in &nums {
+        bst.insert(num);
+    }
+    println!("\n初始化的二元樹為\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+
+    /* 查詢結點 */
+    let node = bst.search(7);
+    println!(
+        "\n查詢到的節點物件為 {:?}，節點值 = {}",
+        node.clone().unwrap(),
+        node.clone().unwrap().borrow().val
+    );
+
+    /* 插入節點 */
+    bst.insert(16);
+    println!("\n插入節點 16 後，二元樹為\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+
+    /* 刪除節點 */
+    bst.remove(1);
+    println!("\n刪除節點 1 後，二元樹為\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+    bst.remove(2);
+    println!("\n刪除節點 2 後，二元樹為\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+    bst.remove(4);
+    println!("\n刪除節點 4 後，二元樹為\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+}
@@ -0,0 +1,39 @@
+/**
+ * File: binary_tree.rs
+ * Created Time: 2023-02-27
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)
+ */
+use std::rc::Rc;
+include!("../include/include.rs");
+use tree_node::TreeNode;
+
+/* Driver Code */
+fn main() {
+    /* 初始化二元樹 */
+    // 初始化節點
+    let n1 = TreeNode::new(1);
+    let n2 = TreeNode::new(2);
+    let n3 = TreeNode::new(3);
+    let n4 = TreeNode::new(4);
+    let n5 = TreeNode::new(5);
+    // 構建節點之間的引用（指標）
+    n1.borrow_mut().left = Some(Rc::clone(&n2));
+    n1.borrow_mut().right = Some(Rc::clone(&n3));
+    n2.borrow_mut().left = Some(Rc::clone(&n4));
+    n2.borrow_mut().right = Some(Rc::clone(&n5));
+    println!("\n初始化二元樹\n");
+    print_util::print_tree(&n1);
+
+    // 插入節點與刪除節點
+    let p = TreeNode::new(0);
+    // 在 n1 -> n2 中間插入節點 P
+    p.borrow_mut().left = Some(Rc::clone(&n2));
+    n1.borrow_mut().left = Some(Rc::clone(&p));
+    println!("\n插入節點 P 後\n");
+    print_util::print_tree(&n1);
+    // 刪除節點 P
+    drop(p);
+    n1.borrow_mut().left = Some(Rc::clone(&n2));
+    println!("\n刪除節點 P 後\n");
+    print_util::print_tree(&n1);
+}
@@ -0,0 +1,45 @@
+/*
+ * File: binary_tree_bfs.rs
+ * Created Time: 2023-04-07
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)
+ */
+
+include!("../include/include.rs");
+
+use std::collections::VecDeque;
+use std::{cell::RefCell, rc::Rc};
+use tree_node::{vec_to_tree, TreeNode};
+
+/* 層序走訪 */
+fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
+    // 初始化佇列，加入根節點
+    let mut que = VecDeque::new();
+    que.push_back(Rc::clone(&root));
+    // 初始化一個串列，用於儲存走訪序列
+    let mut vec = Vec::new();
+
+    while let Some(node) = que.pop_front() {
+        // 隊列出隊
+        vec.push(node.borrow().val); // 儲存節點值
+        if let Some(left) = node.borrow().left.as_ref() {
+            que.push_back(Rc::clone(left)); // 左子節點入列
+        }
+        if let Some(right) = node.borrow().right.as_ref() {
+            que.push_back(Rc::clone(right)); // 右子節點入列
+        };
+    }
+    vec
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化二元樹 */
+    // 這裡藉助了一個從陣列直接生成二元樹的函式
+    let root = vec_to_tree(op_vec![1, 2, 3, 4, 5, 6, 7]).unwrap();
+    println!("初始化二元樹\n");
+    print_util::print_tree(&root);
+
+    /* 層序走訪 */
+    let vec = level_order(&root);
+    print!("\n層序走訪的節點列印序列 = {:?}", vec);
+}
@@ -0,0 +1,71 @@
+/*
+ * File: binary_tree_dfs.rs
+ * Created Time: 2023-04-06
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)
+ */
+
+include!("../include/include.rs");
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use tree_node::{vec_to_tree, TreeNode};
+
+/* 前序走訪 */
+fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    if let Some(node) = root {
+        // 訪問優先順序：根節點 -> 左子樹 -> 右子樹
+        result.push(node.borrow().val);
+        result.append(&mut pre_order(node.borrow().left.as_ref()));
+        result.append(&mut pre_order(node.borrow().right.as_ref()));
+    }
+    result
+}
+
+/* 中序走訪 */
+fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    if let Some(node) = root {
+        // 訪問優先順序：左子樹 -> 根節點 -> 右子樹
+        result.append(&mut in_order(node.borrow().left.as_ref()));
+        result.push(node.borrow().val);
+        result.append(&mut in_order(node.borrow().right.as_ref()));
+    }
+    result
+}
+
+/* 後序走訪 */
+fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    if let Some(node) = root {
+        // 訪問優先順序：左子樹 -> 右子樹 -> 根節點
+        result.append(&mut post_order(node.borrow().left.as_ref()));
+        result.append(&mut post_order(node.borrow().right.as_ref()));
+        result.push(node.borrow().val);
+    }
+    result
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化二元樹 */
+    // 這裡藉助了一個從陣列直接生成二元樹的函式
+    let root = vec_to_tree(op_vec![1, 2, 3, 4, 5, 6, 7]);
+    println!("初始化二元樹\n");
+    print_util::print_tree(root.as_ref().unwrap());
+
+    /* 前序走訪 */
+    let vec = pre_order(root.as_ref());
+    println!("\n前序走訪的節點列印序列 = {:?}", vec);
+
+    /* 中序走訪 */
+    let vec = in_order(root.as_ref());
+    println!("\n中序走訪的節點列印序列 = {:?}", vec);
+
+    /* 後序走訪 */
+    let vec = post_order(root.as_ref());
+    print!("\n後序走訪的節點列印序列 = {:?}", vec);
+}