build

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;
             }

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;

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;
             }
         }
     }

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
     }
     ```