build

chapter_computational_complexity/iteration_and_recursion.md

@@ -1591,7 +1591,24 @@ status: new
 === "Rust"
 
     ```rust title="recursion.rs"
-    [class]{}-[func]{for_loop_recur}
+    /* 使用迭代模拟递归 */
+    fn for_loop_recur(n: i32) -> i32 {
+        // 使用一个显式的栈来模拟系统调用栈
+        let mut stack = Vec::new();
+        let mut res = 0;
+        // 递：递归调用
+        for i in (1..=n).rev() {
+            // 通过“入栈操作”模拟“递”
+            stack.push(i);
+        }
+        // 归：返回结果
+        while !stack.is_empty() {
+            // 通过“出栈操作”模拟“归”
+            res += stack.pop().unwrap();
+        }
+        // res = 1+2+3+...+n
+        res
+    }
     ```
 
 === "C"

chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -374,17 +374,17 @@ comments: true
 
     ```rust title="build_tree.rs"
     /* 构建二叉树：分治 */
-    fn dfs(preorder: &[i32], inorderMap: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
+    fn dfs(preorder: &[i32], inorder_map: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
         // 子树区间为空时终止
         if r - l < 0 { return None; }
         // 初始化根节点
         let root = TreeNode::new(preorder[i as usize]);
         // 查询 m ，从而划分左右子树
-        let m = inorderMap.get(&preorder[i as usize]).unwrap();
+        let m = inorder_map.get(&preorder[i as usize]).unwrap();
         // 子问题：构建左子树
-        root.borrow_mut().left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);
         // 子问题：构建右子树
-        root.borrow_mut().right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);
         // 返回根节点
         Some(root)
     }
@@ -392,11 +392,11 @@ comments: true
     /* 构建二叉树 */
     fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
         // 初始化哈希表，存储 inorder 元素到索引的映射
-        let mut inorderMap: HashMap<i32, i32> = HashMap::new();
+        let mut inorder_map: HashMap<i32, i32> = HashMap::new();
         for i in 0..inorder.len() {
-            inorderMap.insert(inorder[i], i as i32);
+            inorder_map.insert(inorder[i], i as i32);
         }
-        let root = dfs(preorder, &inorderMap, 0, 0, inorder.len() as i32 - 1);
+        let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);
         root
     }
     ```

chapter_stack_and_queue/deque.md

@@ -4,7 +4,7 @@ comments: true
 
 # 5.3   双向队列
 
-在队列中，我们仅能在头部删除或在尾部添加元素。如图 5-7 所示，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
+在队列中，我们仅能在头部删除或在尾部添加元素。如图 5-7 所示，「双向队列 double-ended queue」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
 
 ![双向队列的操作](deque.assets/deque_operations.png)
 

chapter_tree/binary_tree.md

@@ -91,10 +91,15 @@ comments: true
 
     ```javascript title=""
     /* 二叉树节点类 */
-    function TreeNode(val, left, right) {
+    class TreeNode {
-        this.val = (val === undefined ? 0 : val); // 节点值
+        val; // 节点值
-        this.left = (left === undefined ? null : left); // 左子节点引用
+        left; // 左子节点指针
-        this.right = (right === undefined ? null : right); // 右子节点引用
+        right; // 右子节点指针
+        constructor(val, left, right) {
+            this.val = val === undefined ? 0 : val;
+            this.left = left === undefined ? null : left;
+            this.right = right === undefined ? null : right;
+        }
     }
     ```