no message

Author: wuduhren

problems/construct-binary-tree-from-inorder-and-postorder-traversal.py

@@ -0,0 +1,71 @@
+"""
+inorder: [LEFT]root[RIGHT]
+postorder: [LEFT][RIGHT]root
+
+First thing we know is the value of root, which is the last element of `postorder`.
+Find the index of the root in `inorder`. So find out the interval of [LEFT] and [RIGHT] in `inorder`.
+
+The length of the [LEFT] and [RIGHT] in `inorder` are the same with the length of the [LEFT] and [RIGHT] in `postorder`.
+"""
+class Solution(object):
+    def buildTree(self, inorder, postorder):
+        if not inorder or not postorder: return None
+        
+        root = TreeNode(postorder[-1])
+        if len(inorder)==1: return root
+        
+        r = inorder.index(root.val)
+        
+        leftInOrder = inorder[:r]
+        leftPostOrder = postorder[:r]
+        rightInOrder = inorder[r+1:]
+        rightPostOrder = postorder[r:len(postorder)-1]
+        
+        root.left = self.buildTree(leftInOrder, leftPostOrder)
+        root.right = self.buildTree(rightInOrder, rightPostOrder)
+        
+        return root
+"""
+Time: O(NLogN). For each node, we need to do an iteration to its children. To be precise..
+O(N) for constructing root.
+
+O(N/2) for constructing root.left
+O(N/2) for constructing root.right
+
+O(N/4) for constructing root.left.left
+O(N/4) for constructing root.left.right
+O(N/4) for constructing root.right.left
+O(N/4) for constructing root.right.right
+...
+
+To improve this, we can use a hash table to get the index of `i` below
+
+
+Space: O(NLogN).
+For each node, we need to construct inorder/postorder arrays of its children.
+We can improve this by using pointers.
+"""
+
+"""
+Improved version.
+Time: O(N).
+Space: O(N). For `index`.
+"""
+class Solution(object):
+    def buildTree(self, inorder, postorder):
+        def helper(i, j, k, l):
+            if j-i<=0: return None
+            if l-k<=0: return None
+            
+            root = TreeNode(postorder[l-1])
+            if j-i==1: return root
+
+            r = index[root.val]
+            
+            root.left = helper(i, r, k, k+r-i)
+            root.right = helper(r+1, j, k+r-i, l-1)
+            return root
+        
+        index = {} #the index of inorder
+        for i, n in enumerate(inorder): index[n] = i
+        return helper(0, len(inorder), 0, len(postorder))

problems/construct-binary-tree-from-preorder-and-inorder-traversal.py

@@ -0,0 +1,30 @@
+"""
+Time: O(N)
+Space: O(N)
+
+preorder: root[LEFT][RIGHT]
+inorder: [LEFT]root[RIGHT]
+
+The `helper()` will return the root node from `preorder` and `inorder`.
+If they have left or right child, call `helper()` again to get the left or right node.
+
+Use pointers to represent array, avoiding keep copying `preorder` and `inorder`.
+i and j represent the preorder[i:j]
+k and l epresent the inorder[k:l]
+"""
+class Solution(object):
+    def buildTree(self, preorder, inorder):
+        def helper(i, j, k, l):
+            root = TreeNode(preorder[i])
+            
+            r = inorderIndex[root.val] #the index of the root val in inorder
+            leftLength = r-k
+            rightLength = l-(r+1)
+            
+            if leftLength>0: root.left = helper(i+1, i+1+leftLength, k, k+leftLength)
+            if rightLength>0: root.right = helper(i+1+leftLength, i+1+leftLength+rightLength, r+1, r+1+rightLength)
+            return root
+        
+        inorderIndex = {}
+        for i, n in enumerate(inorder): inorderIndex[n] = i
+        return helper(0, len(preorder), 0, len(inorder))

problems/convert-sorted-array-to-binary-search-tree.py

@@ -19,4 +19,34 @@ def sortedArrayToBST(self, nums):
 
 Time: O(N). Because there will be N element being construct.
 Space: O(LogN). There will be LogN level of recursive call.
-"""
+"""
+
+
+
+"""
+Time: O(N)
+Space: O(LogN)
+
+To make it height-balanced
+We need to make sure that the number of nodes in left substree and right subtree be the same.
+Since the `nums` is already sorted, the best nodes to be root is the one in the middle.
+
+`helper()` will get the root node from the nums[i:j].
+If it has left child, it will recursively call `helper()` to get the child.
+
+Use pointers i and j as param to avoid keep copying `nums`.
+"""
+class Solution(object):
+    def sortedArrayToBST(self, nums):
+        def helper(i, j):
+            m = (i+j)/2
+            node = TreeNode(nums[m])
+            
+            leftLength = m-i #number of nodes in the left subtree
+            rightLength = j-(m+1) #number of nodes in the right subtree
+            
+            if leftLength>0: node.left = helper(i, m)
+            if rightLength>0: node.right = helper(m+1, j)
+            return node
+        
+        return helper(0, len(nums))