no message

Author: wuduhren

README.md

@@ -11,10 +11,12 @@ Please [BUY ME A COFFEE](https://www.buymeacoffee.com/chriswu) if you want to sh
 
 
 # Leetcode Problem Lists
-* https://leetcode.com/list/?selectedList=535ukjh5 (Only 74 problems)
+I found it makes sense to solve similar problems together, so that we can recognize the problem faster when we encounter a new one. My suggestion is to skip the HARD problems when you first go through these list.
+
 * https://www.programcreek.com/2013/08/leetcode-problem-classification/
 * https://github.com/wisdompeak/LeetCode
 * https://docs.google.com/spreadsheets/d/1SbpY-04Cz8EWw3A_LBUmDEXKUMO31DBjfeMoA0dlfIA/edit#gid=126913158 ([huahua](https://www.youtube.com/user/xxfflower/videos)).
+* https://leetcode.com/list/?selectedList=535ukjh5 (Only 74 problems)
 
 
 # Software Engineer Interview

problems/balanced-binary-tree.py

@@ -24,4 +24,25 @@ def helper(node, depth):
             return -1
 
         if not root: return True
-        return helper(root, 0)!=-1
+        return helper(root, 0)!=-1
+
+
+"""
+Time: O(N), since we recursively traverse each node once.
+Space: O(LogN), for the recursive call. O(N) if the tree is not balanced.
+"""
+class Solution(object):
+    def isBalanced(self, root):
+        
+        #return (if the node isBalanced, the height of the node)
+        def helper(node):
+            if not node: return True, -1
+            
+            isLeftBalanced, leftHeight = helper(node.left)
+            isRightBalanced, rightHeight = helper(node.right)
+            
+            height = max(leftHeight, rightHeight)+1
+            
+            return isLeftBalanced and isRightBalanced and abs(leftHeight-rightHeight)<=1, height
+        
+        return helper(root)[0]

problems/minimum-depth-of-binary-tree.py

@@ -18,4 +18,27 @@ def minDepth(self, root):
             if node.left:
                 q.append((node.left, depth+1))
             if node.right:
-                q.append((node.right, depth+1))
+                q.append((node.right, depth+1))
+
+
+
+"""
+Time: O(N)
+Space: O(N)
+
+Standard BFS on a binary tree.
+"""
+class Solution(object):
+    def minDepth(self, root):
+        if not root: return 0
+        q = collections.deque([(root, 1)])
+        
+        while q:
+            node, depth = q.popleft()
+            
+            if not node.left and not node.right: return depth
+            
+            if node.left: q.append((node.left, depth+1))
+            if node.right: q.append((node.right, depth+1))
+        
+        return 'ERROR'

problems/symmetric-tree.py

@@ -33,4 +33,35 @@ def isSymmetric(self, root):
 #                 if left_node.val!=right_node.val: return False
 #                 stack.append((left_node.right, right_node.left))
 #                 stack.append((left_node.left, right_node.right))
-#         return True
+#         return True
+
+"""
+Time: O(N)
+Space: O(N)
+
+Use 2 DFS to traverse the tree at the same time.
+s1 will go left first.
+s2 will fo right first.
+Make sure every element popping out is the same.
+"""
+class Solution(object):
+    def isSymmetric(self, root):
+        s1 = [root]
+        s2 = [root]
+        
+        while s1 and s2:
+            node1 = s1.pop()
+            node2 = s2.pop()
+            
+            if not node1 and not node2: continue
+            if not node1 and node2: return False
+            if node1 and not node2: return False
+            if node1.val!=node2.val: return False
+            
+            s1.append(node1.left)
+            s1.append(node1.right)
+            s2.append(node2.right)                
+            s2.append(node2.left)
+        
+        if s1 or s2: return False #if there are something left in one of the stack
+        return True