no message

Author: wuduhren

problems/closest-binary-search-tree-value.py

@@ -0,0 +1,24 @@
+"""
+Time: O(LogN)
+Space: O(1)
+
+Basically we are going to search the target in the BST.
+Along the way, we compare it with the `ans`, if the difference is smaller, update it.
+"""
+class Solution(object):
+    def closestValue(self, root, target):
+        node = root
+        ans = float('inf')
+        
+        while node:
+            if not node: break
+            
+            if abs(ans-target)>abs(node.val-target):
+                ans = node.val
+            
+            if target>node.val:
+                node = node.right
+            else:
+                node = node.left
+                
+        return ans

problems/count-complete-tree-nodes.py

@@ -0,0 +1,27 @@
+"""
+Time: O(H^2). The time complexity will countNodes() will be LogH if the tree is perfect.
+If not, we will need Log(H-1)
+
+Space: O(H)
+"""
+class Solution(object):
+    def countNodes(self, root):
+        if not root: return 0
+        
+        node = root
+        l = 1 #level on the right side
+        while node.left:
+            node = node.left
+            l += 1
+        
+        node = root
+        r = 1 #level on the left side
+        while node.right:
+            node = node.right
+            r += 1
+        
+        if l==r:
+            #perfect tree
+            return (2**r)-1
+        else:
+            return 1+self.countNodes(root.left)+self.countNodes(root.right)

problems/sum-root-to-leaf-numbers.py

@@ -43,6 +43,30 @@ def sumNumbers(self, root):
 """
 
 
+"""
+Time: O(N)
+Space: O(H)
+
+Use standard DFS to traverse the tree.
+"""
+class Solution(object):
+    def sumNumbers(self, root):
+        ans = 0
+        stack = [(root, '')]
+        
+        while stack:
+            node, numString = stack.pop()
+            
+            if node.left:
+                stack.append((node.left, numString+str(node.val)))
+            if node.right:
+                stack.append((node.right, numString+str(node.val)))
+            
+            if not node.left and not node.right:
+                ans += int(numString+str(node.val))
+        return ans
+
+
 
 
 

problems/unique-binary-search-trees-ii,py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def generateTrees(self, N):
+        
+        #generateTrees from s to e
+        def helper(s, e):
+            trees = []
+            
+            for i in xrange(s, e+1):
+                leftTrees = helper(s, i-1)
+                rightTrees = helper(i+1, e)
+                
+                for leftTree in leftTrees:
+                    for rightTree in rightTrees:
+                        
+                        root = TreeNode(i)
+                        root.left = leftTree
+                        root.right = rightTree
+                        trees.append(root)
+            
+            return trees if trees else [None]
+        
+        #remove None in the output
+        return [tree for tree in helper(1, N) if tree]