build

zh-Hant/docs/chapter_tree/array_representation_of_tree.md

@@ -1020,18 +1020,11 @@ comments: true
 
         /* 層序走訪 */
         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
+            self.tree.iter().filter_map(|&x| x).collect()
         }
 
         /* 深度優先走訪 */
-        fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {
+        fn dfs(&self, i: i32, order: &'static str, res: &mut Vec<i32>) {
             if self.val(i).is_none() {
                 return;
             }

zh-Hant/docs/chapter_tree/avl_tree.md

@@ -188,7 +188,7 @@ AVL 樹既是二元搜尋樹，也是平衡二元樹，同時滿足這兩類二
 
     ```c title=""
     /* AVL 樹節點結構體 */
-    TreeNode struct TreeNode {
+    typedef struct TreeNode {
         int val;
         int height;
         struct TreeNode *left;

zh-Hant/docs/chapter_tree/binary_search_tree.md

@@ -1447,7 +1447,7 @@ comments: true
                 // 刪除節點 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) {
+                    if left.is_some() && Rc::ptr_eq(left.as_ref().unwrap(), &cur) {
                         pre.borrow_mut().left = child;
                     } else {
                         pre.borrow_mut().right = child;
@@ -1468,11 +1468,11 @@ comments: true
                         break;
                     }
                 }
-                let tmpval = tmp.unwrap().borrow().val;
+                let tmp_val = tmp.unwrap().borrow().val;
                 // 遞迴刪除節點 tmp
-                self.remove(tmpval);
+                self.remove(tmp_val);
                 // 用 tmp 覆蓋 cur
-                cur.borrow_mut().val = tmpval;
+                cur.borrow_mut().val = tmp_val;
             }
         }
     }

zh-Hant/docs/chapter_tree/binary_tree_traversal.md

@@ -700,12 +700,17 @@ comments: true
     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.extend(pre_order(node.borrow().left.as_ref()));
-            result.extend(pre_order(node.borrow().right.as_ref()));
+        fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+            if let Some(node) = root {
+                // 訪問優先順序：根節點 -> 左子樹 -> 右子樹
+                let node = node.borrow();
+                res.push(node.val);
+                dfs(node.left.as_ref(), res);
+                dfs(node.right.as_ref(), res);
+            }
         }
+        dfs(root, &mut result);
+
         result
     }
 
@@ -713,12 +718,17 @@ comments: true
     fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
         let mut result = vec![];
 
-        if let Some(node) = root {
-            // 訪問優先順序：左子樹 -> 根節點 -> 右子樹
-            result.extend(in_order(node.borrow().left.as_ref()));
-            result.push(node.borrow().val);
-            result.extend(in_order(node.borrow().right.as_ref()));
+        fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+            if let Some(node) = root {
+                // 訪問優先順序：左子樹 -> 根節點 -> 右子樹
+                let node = node.borrow();
+                dfs(node.left.as_ref(), res);
+                res.push(node.val);
+                dfs(node.right.as_ref(), res);
+            }
         }
+        dfs(root, &mut result);
+
         result
     }
 
@@ -726,12 +736,18 @@ comments: true
     fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
         let mut result = vec![];
 
-        if let Some(node) = root {
-            // 訪問優先順序：左子樹 -> 右子樹 -> 根節點
-            result.extend(post_order(node.borrow().left.as_ref()));
-            result.extend(post_order(node.borrow().right.as_ref()));
-            result.push(node.borrow().val);
+        fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+            if let Some(node) = root {
+                // 訪問優先順序：左子樹 -> 右子樹 -> 根節點
+                let node = node.borrow();
+                dfs(node.left.as_ref(), res);
+                dfs(node.right.as_ref(), res);
+                res.push(node.val);
+            }
         }
+
+        dfs(root, &mut result);
+
         result
     }
     ```