feat: update solutions to lcof problems

YangFong · YangFong · commit 57ec4f2b970b · 2022-05-17T08:35:17.000+08:00
diff --git a/lcof/面试题26. 树的子结构/README.md b/lcof/面试题26. 树的子结构/README.md
@@ -199,20 +199,17 @@ function isSubStructure(A: TreeNode | null, B: TreeNode | null): boolean {
     if (A == null || B == null) {
         return false;
     }
-    if (A.val == B.val && exam(A.left, B.left) && exam(A.right, B.right)) {
-        return true;
-    }
-    return isSubStructure(A.left, B) || isSubStructure(A.right, B);
+    return dfs(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
 }
 
-function exam(A: TreeNode | null, B: TreeNode | null) {
+function dfs(A: TreeNode | null, B: TreeNode | null) {
     if (B == null) {
         return true;
     }
     if (A == null) {
         return false;
     }
-    return A.val === B.val && exam(A.left, B.left) && exam(A.right, B.right);
+    return A.val === B.val && dfs(A.left, B.left) && dfs(A.right, B.right);
 }
 ```
 
@@ -239,38 +236,37 @@ function exam(A: TreeNode | null, B: TreeNode | null) {
 // }
 use std::rc::Rc;
 use std::cell::RefCell;
-
 impl Solution {
     pub fn is_sub_structure(
         a: Option<Rc<RefCell<TreeNode>>>,
         b: Option<Rc<RefCell<TreeNode>>>,
+    ) -> bool {
+        Self::is_sub_structure_help(&a, &b)
+    }
+
+    fn is_sub_structure_help(
+        a: &Option<Rc<RefCell<TreeNode>>>,
+        b: &Option<Rc<RefCell<TreeNode>>>,
     ) -> bool {
         if a.is_none() || b.is_none() {
             return false;
         }
-        let a_ref = a.as_ref().unwrap().borrow();
-        let b_ref = b.as_ref().unwrap().borrow();
 
-        if a_ref.val == b_ref.val
-            && Solution::exam(&a_ref.left, &b_ref.left)
-            && Solution::exam(&a_ref.right, &b_ref.right)
-        {
-            return true;
-        }
-        Solution::is_sub_structure(a_ref.left.clone(), b.clone())
-            || Solution::is_sub_structure(a_ref.right.clone(), b.clone())
+        Self::dfs(a, b)
+            || Self::is_sub_structure_help(&a.as_ref().unwrap().borrow().left, b)
+            || Self::is_sub_structure_help(&a.as_ref().unwrap().borrow().right, b)
     }
 
-    fn exam(a: &Option<Rc<RefCell<TreeNode>>>, b: &Option<Rc<RefCell<TreeNode>>>) -> bool {
-        if a.is_none() && b.is_some() {
-            return false;
-        }
-        if b.is_none() || a.is_none() && b.is_none() {
+    fn dfs(a: &Option<Rc<RefCell<TreeNode>>>, b: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if b.is_none() {
             return true;
         }
+        if a.is_none() {
+            return false;
+        }
         let a = a.as_ref().unwrap().borrow();
         let b = b.as_ref().unwrap().borrow();
-        a.val == b.val && Solution::exam(&a.left, &b.left) && Solution::exam(&a.right, &b.right)
+        a.val == b.val && Self::dfs(&a.left, &b.left) && Self::dfs(&a.right, &b.right)
     }
 }
 ```
diff --git a/lcof/面试题26. 树的子结构/Solution.rs b/lcof/面试题26. 树的子结构/Solution.rs
@@ -18,37 +18,36 @@
 // }
 use std::rc::Rc;
 use std::cell::RefCell;
-
 impl Solution {
     pub fn is_sub_structure(
         a: Option<Rc<RefCell<TreeNode>>>,
         b: Option<Rc<RefCell<TreeNode>>>,
+    ) -> bool {
+        Self::is_sub_structure_help(&a, &b)
+    }
+
+    fn is_sub_structure_help(
+        a: &Option<Rc<RefCell<TreeNode>>>,
+        b: &Option<Rc<RefCell<TreeNode>>>,
     ) -> bool {
         if a.is_none() || b.is_none() {
             return false;
         }
-        let a_ref = a.as_ref().unwrap().borrow();
-        let b_ref = b.as_ref().unwrap().borrow();
 
-        if a_ref.val == b_ref.val
-            && Solution::exam(&a_ref.left, &b_ref.left)
-            && Solution::exam(&a_ref.right, &b_ref.right)
-        {
-            return true;
-        }
-        Solution::is_sub_structure(a_ref.left.clone(), b.clone())
-            || Solution::is_sub_structure(a_ref.right.clone(), b.clone())
+        Self::dfs(a, b)
+            || Self::is_sub_structure_help(&a.as_ref().unwrap().borrow().left, b)
+            || Self::is_sub_structure_help(&a.as_ref().unwrap().borrow().right, b)
     }
 
-    fn exam(a: &Option<Rc<RefCell<TreeNode>>>, b: &Option<Rc<RefCell<TreeNode>>>) -> bool {
-        if a.is_none() && b.is_some() {
-            return false;
-        }
-        if b.is_none() || a.is_none() && b.is_none() {
+    fn dfs(a: &Option<Rc<RefCell<TreeNode>>>, b: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if b.is_none() {
             return true;
         }
+        if a.is_none() {
+            return false;
+        }
         let a = a.as_ref().unwrap().borrow();
         let b = b.as_ref().unwrap().borrow();
-        a.val == b.val && Solution::exam(&a.left, &b.left) && Solution::exam(&a.right, &b.right)
+        a.val == b.val && Self::dfs(&a.left, &b.left) && Self::dfs(&a.right, &b.right)
     }
 }
diff --git a/lcof/面试题26. 树的子结构/Solution.ts b/lcof/面试题26. 树的子结构/Solution.ts
@@ -16,18 +16,15 @@ function isSubStructure(A: TreeNode | null, B: TreeNode | null): boolean {
     if (A == null || B == null) {
         return false;
     }
-    if (A.val == B.val && exam(A.left, B.left) && exam(A.right, B.right)) {
-        return true;
-    }
-    return isSubStructure(A.left, B) || isSubStructure(A.right, B);
+    return dfs(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
 }
 
-function exam(A: TreeNode | null, B: TreeNode | null) {
+function dfs(A: TreeNode | null, B: TreeNode | null) {
     if (B == null) {
         return true;
     }
     if (A == null) {
         return false;
     }
-    return A.val === B.val && exam(A.left, B.left) && exam(A.right, B.right);
+    return A.val === B.val && dfs(A.left, B.left) && dfs(A.right, B.right);
 }
diff --git a/lcof/面试题27. 二叉树的镜像/README.md b/lcof/面试题27. 二叉树的镜像/README.md
@@ -211,23 +211,22 @@ function mirrorTree(root: TreeNode | null): TreeNode | null {
 //     }
 //   }
 // }
-use std::mem;
 use std::rc::Rc;
 use std::cell::RefCell;
-
 impl Solution {
-    pub fn mirror_tree(mut root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
-        fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) {
-            if let Some(node) = root {
-                let mut node = node.borrow_mut();
-                let lt = mem::replace(&mut node.left, None);
-                let rt = mem::replace(&mut node.right, lt);
-                mem::replace(&mut node.left, rt);
-                dfs(&node.left);
-                dfs(&node.right);
-            }
+    fn dfs(root: &mut Option<Rc<RefCell<TreeNode>>>) {
+        if let Some(node) = root {
+            let mut node = node.borrow_mut();
+            let temp = node.left.take();
+            node.left = node.right.take();
+            node.right = temp;
+            Self::dfs(&mut node.left);
+            Self::dfs(&mut node.right);
         }
-        dfs(&root);
+    }
+
+    pub fn mirror_tree(mut root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        Self::dfs(&mut root);
         root
     }
 }
diff --git a/lcof/面试题27. 二叉树的镜像/Solution.rs b/lcof/面试题27. 二叉树的镜像/Solution.rs
@@ -16,23 +16,22 @@
 //     }
 //   }
 // }
-use std::mem;
 use std::rc::Rc;
 use std::cell::RefCell;
-
 impl Solution {
-    pub fn mirror_tree(mut root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
-        fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) {
-            if let Some(node) = root {
-                let mut node = node.borrow_mut();
-                let lt = mem::replace(&mut node.left, None);
-                let rt = mem::replace(&mut node.right, lt);
-                mem::replace(&mut node.left, rt);
-                dfs(&node.left);
-                dfs(&node.right);
-            }
+    fn dfs(root: &mut Option<Rc<RefCell<TreeNode>>>) {
+        if let Some(node) = root {
+            let mut node = node.borrow_mut();
+            let temp = node.left.take();
+            node.left = node.right.take();
+            node.right = temp;
+            Self::dfs(&mut node.left);
+            Self::dfs(&mut node.right);
         }
-        dfs(&root);
+    }
+
+    pub fn mirror_tree(mut root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        Self::dfs(&mut root);
         root
     }
 }
diff --git a/lcof/面试题28. 对称的二叉树/README.md b/lcof/面试题28. 对称的二叉树/README.md
@@ -160,21 +160,17 @@ func isSymme(left *TreeNode, right *TreeNode) bool {
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
-
 class Solution {
 public:
-    bool isSymmetric(TreeNode* a, TreeNode* b) {
-        // 均为空，则直接返回true。有且仅有一个不为空，则返回false
-        if (a == nullptr && b == nullptr) {
+    bool isSymmetric(TreeNode* left, TreeNode* right) {
+        // 均为空，则直接返回 true。有且仅有一个不为空，则返回 false
+        if (left == nullptr && right == nullptr) {
             return true;
-        } else if (a == nullptr && b != nullptr) {
-            return false;
-        } else if (a != nullptr && b == nullptr) {
+        }
+        if (left == nullptr || right == nullptr || left->val != right->val) {
             return false;
         }
-
-        // 判定值是否相等，和下面的节点是否对称
-        return (a->val == b->val) && isSymmetric(a->left, b->right) && isSymmetric(a->right, b->left);
+        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
     }
 
     bool isSymmetric(TreeNode* root) {
@@ -185,7 +181,6 @@ public:
         return isSymmetric(root->left, root->right);
     }
 };
-
 ```
 
 ### **TypeScript**
@@ -209,19 +204,14 @@ function isSymmetric(root: TreeNode | null): boolean {
     if (root == null) {
         return true;
     }
-    const dfs = (l: TreeNode | null, r: TreeNode | null) => {
-        if (l == null && r == null) {
+    const dfs = (left: TreeNode | null, right: TreeNode | null) => {
+        if (left == null && right == null) {
             return true;
         }
-        if (l == null || r == null) {
+        if (left == null || right == null || left.val != right.val) {
             return false;
         }
-        return (
-            l.val == r.val &&
-            dfs(l.left, r.right) &&
-            dfs(l.right, r.left) &&
-            true
-        );
+        return dfs(left.left, right.right) && dfs(left.right, right.left);
     };
     return dfs(root.left, root.right);
 }
@@ -248,34 +238,29 @@ function isSymmetric(root: TreeNode | null): boolean {
 //     }
 //   }
 // }
-use std::cell::RefCell;
 use std::rc::Rc;
+use std::cell::RefCell;
 impl Solution {
+    fn dfs(left: &Option<Rc<RefCell<TreeNode>>>, right: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if left.is_none() && right.is_none() {
+            return true;
+        }
+        if left.is_none() || right.is_none() {
+            return false;
+        }
+        let l = left.as_ref().unwrap().borrow();
+        let r = right.as_ref().unwrap().borrow();
+        l.val == r.val && Self::dfs(&l.left, &r.right) && Self::dfs(&l.right, &r.left)
+    }
+
     pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
-        match root {
-            None => true,
-            Some(root) => {
-                fn dfs(
-                    l: &Option<Rc<RefCell<TreeNode>>>,
-                    r: &Option<Rc<RefCell<TreeNode>>>,
-                ) -> bool {
-                    if l.is_none() && r.is_none() {
-                        return true;
-                    }
-                    if l.is_none() || r.is_none() {
-                        return false;
-                    }
-                    let l = l.as_ref().unwrap().borrow();
-                    let r = r.as_ref().unwrap().borrow();
-                    l.val == r.val && dfs(&l.left, &r.right) && dfs(&l.right, &r.left) && true
-                }
-                let node = root.borrow();
-                dfs(&node.left, &node.right)
-            }
+        if root.is_none() {
+            return true;
         }
+        let node = root.as_ref().unwrap().borrow();
+        Self::dfs(&node.left, &node.right)
     }
 }
-
 ```
 
 ### **...**
diff --git a/lcof/面试题28. 对称的二叉树/Solution.cpp b/lcof/面试题28. 对称的二叉树/Solution.cpp
@@ -7,21 +7,17 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
-
 class Solution {
 public:
-    bool isSymmetric(TreeNode* a, TreeNode* b) {
-        // 均为空，则直接返回true。有且仅有一个不为空，则返回false
-        if (a == nullptr && b == nullptr) {
+    bool isSymmetric(TreeNode* left, TreeNode* right) {
+        // 均为空，则直接返回 true。有且仅有一个不为空，则返回 false
+        if (left == nullptr && right == nullptr) {
             return true;
-        } else if (a == nullptr && b != nullptr) {
-            return false;
-        } else if (a != nullptr && b == nullptr) {
+        }
+        if (left == nullptr || right == nullptr || left->val != right->val) {
             return false;
         }
-
-        // 判定值是否相等，和下面的节点是否对称
-        return (a->val == b->val) && isSymmetric(a->left, b->right) && isSymmetric(a->right, b->left);
+        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
     }
 
     bool isSymmetric(TreeNode* root) {
diff --git a/lcof/面试题28. 对称的二叉树/Solution.rs b/lcof/面试题28. 对称的二叉树/Solution.rs
diff --git a/lcof/面试题28. 对称的二叉树/Solution.ts b/lcof/面试题28. 对称的二叉树/Solution.ts

Original file line number	Diff line number	Diff line change
`@@ -16,18 +16,15 @@ function isSubStructure(A: TreeNode \| null, B: TreeNode \| null): boolean {`
`16`	`16`	`if (A == null \|\| B == null) {`
`17`	`17`	`return false;`
`18`	`18`	`}`
`19`		`- if (A.val == B.val && exam(A.left, B.left) && exam(A.right, B.right)) {`
`20`		`- return true;`
`21`		`- }`
`22`		`- return isSubStructure(A.left, B) \|\| isSubStructure(A.right, B);`
	`19`	`+ return dfs(A, B) \|\| isSubStructure(A.left, B) \|\| isSubStructure(A.right, B);`
`23`	`20`	`}`
`24`	`21`
`25`		`-function exam(A: TreeNode \| null, B: TreeNode \| null) {`
	`22`	`+function dfs(A: TreeNode \| null, B: TreeNode \| null) {`
`26`	`23`	`if (B == null) {`
`27`	`24`	`return true;`
`28`	`25`	`}`
`29`	`26`	`if (A == null) {`
`30`	`27`	`return false;`
`31`	`28`	`}`
`32`		`- return A.val === B.val && exam(A.left, B.left) && exam(A.right, B.right);`
	`29`	`+ return A.val === B.val && dfs(A.left, B.left) && dfs(A.right, B.right);`
`33`	`30`	`}`