2020-09-29

Author: JiayangWu

0100.相同的树/0100-相同的树.py

@@ -13,6 +13,8 @@ def isSameTree(self, p, q):
         """
         if not p and not q:
             return True
-        if not p or not q:
+        if not p and q:
             return False
+        if p and not q:
+            return False 
         return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

0101.对称二叉树/0101-对称二叉树.py

@@ -11,11 +11,14 @@ def isSymmetric(self, root):
         :type root: TreeNode
         :rtype: bool
         """
-        def helper(node1, node2):
-            if not node1:
-                return not node2
-            if not node2:
-                return not node1
-            return node1.val == node2.val and helper(node1.left, node2.right) and helper(node1.right, node2.left)
 
-        return helper(root, root)
+        def isSame(node1, node2):
+            if not node1 and not node2:
+                return True
+            if not node1 and node2:
+                return False
+            if node1 and not node2:
+                return False
+            return node1.val == node2.val and isSame(node1.left, node2.right) and isSame(node1.right, node2.left)
+
+        return isSame(root, root)

0112.路径总和/0112-路径总和.py

@@ -12,8 +12,13 @@ def hasPathSum(self, root, sum):
         :type sum: int
         :rtype: bool
         """
-        if not root:
-            return False
-        if not root.left and not root.right:
-            return root.val == sum
-        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
+        def dfs(node, s):
+            if not node:
+                return False
+
+            s += node.val
+            if not node.left and not node.right:
+                return s == sum
+            return dfs(node.left, s) or dfs(node.right, s)
+
+        return dfs(root, 0)

0113.路径总和II/0113-路径总和II.py

@@ -6,25 +6,23 @@
 #         self.right = None
 
 class Solution(object):
-    def pathSum(self, root, s):
+    def pathSum(self, root, sum):
         """
         :type root: TreeNode
         :type sum: int
         :rtype: List[List[int]]
         """
         res = []
-        def dfs(node, path):
+        def dfs(node, path, s):
             if not node:
-                return
+                return []
+            s += node.val
+            if not node.left and not node.right:
+                if s == sum:
+                    res.append(path + [node.val])
 
-            path += [node.val]
-            if not node.left and not node.right and sum(path) == s:
-                res.append(path[:])
-                
-            dfs(node.left, path)
-            dfs(node.right, path)
-            
-            path.pop()
-            
-        dfs(root, [])
+            dfs(node.left, path + [node.val], s)
+            dfs(node.right, path + [node.val], s)
+
+        dfs(root, [], 0)
         return res

0222.完全二叉树的节点个数/0222-完全二叉树的节点个数.py

@@ -11,26 +11,8 @@ def countNodes(self, root):
         :type root: TreeNode
         :rtype: int
         """
-        if not root:
-            return 0
-
-        self.leavesCnt = 0
-        self.height = 0
-        self.flag = 0
-        def dfs(node, layer):
-            if not node or self.flag:
-                return
-            if not node.left and not node.right:
-                
-                self.height = max(self.height, layer)
-                if layer < self.height:
-                    self.flag = 1
-                else:
-                    self.leavesCnt += 1
-                return 
-            dfs(node.left, layer + 1)
-            dfs(node.right, layer + 1)
-            
-        dfs(root, 0)
-        # print self.leavesCnt
-        return self.leavesCnt + sum([2 ** i for i in range(self.height)] )
+        def dfs(node):
+            if not node:
+                return 0
+            return 1 + dfs(node.left) + dfs(node.right)
+        return dfs(root)

0226.翻转二叉树/0226-翻转二叉树.py

@@ -13,8 +13,9 @@ def invertTree(self, root):
         """
         if not root:
             return root
-        left = root.left
-        right = root.right
-        root.left = self.invertTree(right)
-        root.right = self.invertTree(left)
+        left = self.invertTree(root.left)
+        right = self.invertTree(root.right)
+
+        root.left = right 
+        root.right = left 
         return root