feat: add solutions to lcof problem: No.28

Author: yanglbme

lcof/面试题28. 对称的二叉树/README.md

@@ -42,6 +42,19 @@
 
 ## 解法
 
+**方法一：递归**
+
+我们设计一个递归函数 `dfs`，它接收两个参数 `a` 和 `b`，分别代表两棵树的根节点。我们可以对 `a` 和 `b` 进行如下判断：
+
+-   如果 `a` 和 `b` 都为空，说明两棵树都遍历完了，返回 `true`；
+-   如果 `a` 和 `b` 中有且只有一个为空，说明两棵树的结构不同，返回 `false`；
+-   如果 `a` 和 `b` 的值不相等，说明两棵树的结构不同，返回 `false`；
+-   如果 `a` 和 `b` 的值相等，那么我们分别递归地判断 `a` 的左子树和 `b` 的右子树，以及 `a` 的右子树和 `b` 的左子树是否对称。
+
+最后，我们返回 `dfs(root, root)`，即判断 `root` 的左子树和右子树是否对称。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -57,18 +70,14 @@
 
 class Solution:
     def isSymmetric(self, root: TreeNode) -> bool:
-        def is_symmetric(left, right):
-            if left is None and right is None:
+        def dfs(a, b):
+            if a is None and b is None:
                 return True
-            if left is None or right is None or left.val != right.val:
+            if a is None or b is None or a.val != b.val:
                 return False
-            return is_symmetric(left.left, right.right) and is_symmetric(
-                left.right, right.left
-            )
+            return dfs(a.left, b.right) and dfs(a.right, b.left)
 
-        if root is None:
-            return True
-        return is_symmetric(root.left, root.right)
+        return dfs(root, root)
 ```
 
 ### **Java**
@@ -85,40 +94,47 @@ class Solution:
  */
 class Solution {
     public boolean isSymmetric(TreeNode root) {
-        if (root == null) return true;
-        return isSymmetric(root.left, root.right);
+        return dfs(root, root);
     }
 
-    private boolean isSymmetric(TreeNode left, TreeNode right) {
-        if (left == null && right == null) return true;
-        if (left == null || right == null || left.val != right.val) return false;
-        return isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);
+    private boolean dfs(TreeNode a, TreeNode b) {
+        if (a == null && b == null) {
+            return true;
+        }
+        if (a == null || b == null || a.val != b.val) {
+            return false;
+        }
+        return dfs(a.left, b.right) && dfs(a.right, b.left);
     }
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
+```cpp
 /**
  * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
- * }
- */
-/**
- * @param {TreeNode} root
- * @return {boolean}
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
  */
-var isSymmetric = function (root) {
-    function dfs(left, right) {
-        if (!left && !right) return true;
-        if (!left || !right || left.val != right.val) return false;
-        return dfs(left.left, right.right) && dfs(left.right, right.left);
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        function<bool(TreeNode*, TreeNode*)> dfs = [&](TreeNode* a, TreeNode* b) -> bool {
+            if (!a && !b) {
+                return true;
+            }
+            if (!a || !b || a->val != b->val) {
+                return false;
+            }
+            return dfs(a->left, b->right) && dfs(a->right, b->left);
+        };
+        return dfs(root, root);
     }
-    if (!root) return true;
-    return dfs(root.left, root.right);
 };
 ```
 
@@ -134,55 +150,45 @@ var isSymmetric = function (root) {
  * }
  */
 func isSymmetric(root *TreeNode) bool {
-    if root == nil {
-        return true
-    }
-    return isSymme(root.Left, root.Right)
-}
-
-func isSymme(left *TreeNode, right *TreeNode) bool {
-    if left == nil && right == nil {
-        return true
-    }
-    if left == nil || right == nil || left.Val != right.Val {
-        return false
-    }
-    return isSymme(left.Left, right.Right) && isSymme(left.Right, right.Left)
+	var dfs func(a, b *TreeNode) bool
+	dfs = func(a, b *TreeNode) bool {
+		if a == nil && b == nil {
+			return true
+		}
+		if a == nil || b == nil || a.Val != b.Val {
+			return false
+		}
+		return dfs(a.Left, b.Right) && dfs(a.Right, b.Left)
+	}
+	return dfs(root, root)
 }
 ```
 
-### **C++**
+### **JavaScript**
 
-```cpp
+```js
 /**
  * Definition for a binary tree node.
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
- * };
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
  */
-class Solution {
-public:
-    bool isSymmetric(TreeNode* left, TreeNode* right) {
-        // 均为空，则直接返回 true。有且仅有一个不为空，则返回 false
-        if (left == nullptr && right == nullptr) {
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric = function (root) {
+    const dfs = (a, b) => {
+        if (!a && !b) {
             return true;
         }
-        if (left == nullptr || right == nullptr || left->val != right->val) {
+        if (!a || !b || a.val != b.val) {
             return false;
         }
-        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
-    }
-
-    bool isSymmetric(TreeNode* root) {
-        if (root == nullptr) {
-            return true;
-        }
-
-        return isSymmetric(root->left, root->right);
-    }
+        return dfs(a.left, b.right) && dfs(a.right, b.left);
+    };
+    return dfs(root, root);
 };
 ```
 
@@ -204,19 +210,16 @@ public:
  */
 
 function isSymmetric(root: TreeNode | null): boolean {
-    if (root == null) {
-        return true;
-    }
-    const dfs = (left: TreeNode | null, right: TreeNode | null) => {
-        if (left == null && right == null) {
+    const dfs = (a: TreeNode | null, b: TreeNode | null): boolean => {
+        if (!a && !b) {
             return true;
         }
-        if (left == null || right == null || left.val != right.val) {
+        if (!a || !b || a.val != b.val) {
             return false;
         }
-        return dfs(left.left, right.right) && dfs(left.right, right.left);
+        return dfs(a.left, b.right) && dfs(a.right, b.left);
     };
-    return dfs(root.left, root.right);
+    return dfs(root, root);
 }
 ```
 
@@ -241,27 +244,23 @@ function isSymmetric(root: TreeNode | null): boolean {
 //     }
 //   }
 // }
-use std::rc::Rc;
 use std::cell::RefCell;
+use std::rc::Rc;
 impl Solution {
-    fn dfs(left: &Option<Rc<RefCell<TreeNode>>>, right: &Option<Rc<RefCell<TreeNode>>>) -> bool {
-        if left.is_none() && right.is_none() {
+    fn dfs(a: &Option<Rc<RefCell<TreeNode>>>, b: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if a.is_none() && b.is_none() {
             return true;
         }
-        if left.is_none() || right.is_none() {
+        if a.is_none() || b.is_none() {
             return false;
         }
-        let l = left.as_ref().unwrap().borrow();
-        let r = right.as_ref().unwrap().borrow();
+        let l = a.as_ref().unwrap().borrow();
+        let r = b.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 {
-        if root.is_none() {
-            return true;
-        }
-        let node = root.as_ref().unwrap().borrow();
-        Self::dfs(&node.left, &node.right)
+        Self::dfs(&root, &root)
     }
 }
 ```
@@ -280,20 +279,17 @@ impl Solution {
  */
 public class Solution {
     public bool IsSymmetric(TreeNode root) {
-        if (root == null) {
-            return true;
-        }
-        return dfs(root.left, root.right);
+        return dfs(root, root);
     }
 
-    public bool dfs(TreeNode left, TreeNode right) {
-        if (left == null && right == null) {
+    private bool dfs(TreeNode a, TreeNode b) {
+        if (a == null && b == null) {
             return true;
         }
-        if (left == null || right == null || left.val != right.val) {
+        if (a == null || b == null || a.val != b.val) {
             return false;
         }
-        return dfs(left.left, right.right) && dfs(left.right, right.left);
+        return dfs(a.left, b.right) && dfs(a.right, b.left);
     }
 }
 ```

lcof/面试题28. 对称的二叉树/Solution.cpp

@@ -9,22 +9,16 @@
  */
 class Solution {
 public:
-    bool isSymmetric(TreeNode* left, TreeNode* right) {
-        // 均为空，则直接返回 true。有且仅有一个不为空，则返回 false
-        if (left == nullptr && right == nullptr) {
-            return true;
-        }
-        if (left == nullptr || right == nullptr || left->val != right->val) {
-            return false;
-        }
-        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
-    }
-
     bool isSymmetric(TreeNode* root) {
-        if (root == nullptr) {
-            return true;
-        }
-
-        return isSymmetric(root->left, root->right);
+        function<bool(TreeNode*, TreeNode*)> dfs = [&](TreeNode* a, TreeNode* b) -> bool {
+            if (!a && !b) {
+                return true;
+            }
+            if (!a || !b || a->val != b->val) {
+                return false;
+            }
+            return dfs(a->left, b->right) && dfs(a->right, b->left);
+        };
+        return dfs(root, root);
     }
-};
+};

lcof/面试题28. 对称的二叉树/Solution.cs

@@ -9,19 +9,16 @@
  */
 public class Solution {
     public bool IsSymmetric(TreeNode root) {
-        if (root == null) {
-            return true;
-        }
-        return dfs(root.left, root.right);
+        return dfs(root, root);
     }
 
-    public bool dfs(TreeNode left, TreeNode right) {
-        if (left == null && right == null) {
+    private bool dfs(TreeNode a, TreeNode b) {
+        if (a == null && b == null) {
             return true;
         }
-        if (left == null || right == null || left.val != right.val) {
+        if (a == null || b == null || a.val != b.val) {
             return false;
         }
-        return dfs(left.left, right.right) && dfs(left.right, right.left); 
+        return dfs(a.left, b.right) && dfs(a.right, b.left);
     }
 }

lcof/面试题28. 对称的二叉树/Solution.go

@@ -6,19 +6,16 @@
  *     Right *TreeNode
  * }
  */
- func isSymmetric(root *TreeNode) bool {
-    if root == nil {
-        return true
-    }
-    return isSymme(root.Left, root.Right)
-}
-
-func isSymme(left *TreeNode, right *TreeNode) bool {
-    if left == nil && right == nil {
-        return true
-    }
-    if left == nil || right == nil || left.Val != right.Val {
-        return false
-    }
-    return isSymme(left.Left, right.Right) && isSymme(left.Right, right.Left)
+func isSymmetric(root *TreeNode) bool {
+	var dfs func(a, b *TreeNode) bool
+	dfs = func(a, b *TreeNode) bool {
+		if a == nil && b == nil {
+			return true
+		}
+		if a == nil || b == nil || a.Val != b.Val {
+			return false
+		}
+		return dfs(a.Left, b.Right) && dfs(a.Right, b.Left)
+	}
+	return dfs(root, root)
 }