no message

Author: wuduhren

problems/binary-tree-paths.py

@@ -15,4 +15,28 @@ def binaryTreePaths(self, root):
             if node.left: stack.append((node.left, path))
             if node.right: stack.append((node.right, path))
 
+        return ans
+
+
+"""
+Time: O(N)
+Space: O(N)
+
+Standard BFS.
+"""
+class Solution(object):
+    def binaryTreePaths(self, root):
+        q = collections.deque([(root, '')])
+        ans = []
+        
+        while q:
+            node, path = q.popleft()
+            
+            path = (path+'->'+str(node.val)) if path else str(node.val)
+            
+            if node.left: q.append((node.left, path))
+            if node.right: q.append((node.right, path))
+
+            if not node.left and not node.right: ans.append(path)
+            
         return ans

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

@@ -18,4 +18,28 @@ def maxDepth(self, root):
             if node.right:
                 stack.append((node.right, depth+1))
         return max_depth
-        
+
+
+"""
+Time: O(N)
+Space: O(N)
+
+Standard BFS.
+"""
+class Solution(object):
+    def maxDepth(self, root):
+        if not root: return 0
+        
+        ans = float('-inf')
+        q = collections.deque([(root, 1)])
+        node = root
+        
+        while q:
+            node, d = q.popleft()
+            
+            ans = max(ans, d)
+            
+            if node.left: q.append((node.left, d+1))
+            if node.right: q.append((node.right, d+1))
+        
+        return ans

problems/recover-binary-search-tree.py

@@ -0,0 +1,68 @@
+"""
+Time: O(NLogN)
+Space: O(N)
+"""
+class Solution(object):
+    def recoverTree(self, root):
+        memo = {} #{node.val:node}
+        stack = []
+        node = root
+        vals = []
+        
+        #inorder traversal and store the values in `vals` and `memo`
+        while node or stack:
+            while node:
+                stack.append(node)
+                node = node.left
+            
+            node = stack.pop()
+            
+            memo[node.val] = node
+            vals.append(node.val)
+            
+            node = node.right
+        
+        #find two val that needed to be swapped
+        diff = []
+        sortedVals = sorted(vals)
+        for i in xrange(len(sortedVals)):
+            if vals[i]!=sortedVals[i]: diff.append(vals[i])
+            if len(diff)>=2: break
+        
+        #swap the values
+        memo[diff[0]].val = diff[1]
+        memo[diff[1]].val = diff[0]
+        
+        return root
+
+
+"""
+Time: O(N)
+Space: O(N)
+"""
+class Solution(object):
+    def recoverTree(self, root):
+        stack = []
+        node = root
+        prev = TreeNode(float('-inf'))
+        swap1 = swap2 = None
+        
+        #inorder traversal and find the swapped values
+        while node or stack:
+            while node:
+                stack.append(node)
+                node = node.left
+            
+            node = stack.pop()
+            
+            if swap1==None and prev.val>node.val: swap1 = prev
+            if swap1!=None and prev.val>node.val: swap2 = node
+
+            prev = node
+
+            node = node.right
+        
+        #swap the values
+        swap1.val, swap2.val = swap2.val, swap1.val
+        
+        return root