feat: optimize solutions to lcof problem: No.13

面试题34. 二叉树中和为某一值的路径

Author: YangFong

lcof/面试题34. 二叉树中和为某一值的路径/Solution.rs

@@ -16,44 +16,42 @@
 //     }
 //   }
 // }
-use std::cell::RefCell;
 use std::rc::Rc;
+use std::cell::RefCell;
 
 impl Solution {
-    fn dfs(
-        root: &Option<Rc<RefCell<TreeNode>>>,
-        mut target: i32,
-        mut values: Vec<i32>,
-    ) -> Vec<Vec<i32>> {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, mut target: i32,  paths: &mut Vec<i32>) -> Vec<Vec<i32>> {
         let node = root.as_ref().unwrap().borrow();
-        values.push(node.val);
+        paths.push(node.val);
         target -= node.val;
         let mut res = vec![];
         // 确定叶结点身份
         if node.left.is_none() && node.right.is_none() {
             if target == 0 {
-                res.push(values);
+                res.push(paths.clone());
             }
+            paths.pop();
             return res;
         }
         if node.left.is_some() {
-            let res_l = Solution::dfs(&node.left, target, values.clone());
+            let res_l = Solution::dfs(&node.left, target, paths);
             if !res_l.is_empty() {
                 res = [res, res_l].concat();
             }
         }
         if node.right.is_some() {
-            let res_r = Solution::dfs(&node.right, target, values.clone());
+            let res_r = Solution::dfs(&node.right, target, paths);
             if !res_r.is_empty() {
                 res = [res, res_r].concat();
             }
         }
+        paths.pop();
         res
     }
     pub fn path_sum(root: Option<Rc<RefCell<TreeNode>>>, target: i32) -> Vec<Vec<i32>> {
         if root.is_none() {
             return vec![];
         }
-        Solution::dfs(&root, target, vec![])
+        Solution::dfs(&root, target, &mut vec![])
     }
-}
+}

lcof/面试题34. 二叉树中和为某一值的路径/Solution.ts

@@ -13,26 +13,25 @@
  */
 
 function pathSum(root: TreeNode | null, target: number): number[][] {
-    const res = [];
+    const res: number[][] = [];
     if (root == null) {
         return res;
     }
-    const dfs = (
-        { val, right, left }: TreeNode,
-        target: number,
-        values: number[]
-    ) => {
-        values.push(val);
+    const paths: number[] = [];
+    const dfs = ({ val, right, left }: TreeNode, target: number) => {
+        paths.push(val);
         target -= val;
         if (left == null && right == null) {
             if (target === 0) {
-                res.push(values);
+                res.push([...paths]);
             }
+            paths.pop();
             return;
         }
-        left && dfs(left, target, [...values]);
-        right && dfs(right, target, [...values]);
+        left && dfs(left, target);
+        right && dfs(right, target);
+        paths.pop();
     };
-    dfs(root, target, []);
+    dfs(root, target);
     return res;
 }