no message

Author: wuduhren

problems/convert-binary-search-tree-to-sorted-doubly-linked-list.py

@@ -43,4 +43,62 @@ def helper(node, hook_left=True):
         root.left = right_most
         right_most.right = root
 
-        return root
+        return root
+
+
+
+
+
+"""
+Time: O(N)
+Space: O(LogN) if the tree is balanced.
+
+Do an inorder traversal and link the node.left to the prev and prev.right to node.
+"""
+class Solution(object):
+    def treeToDoublyList(self, root):
+        if not root: return root
+        
+        stack = []
+        node = root
+        preHead = Node(-1)
+        prev = preHead
+        
+        while node or stack:
+            while node:
+                stack.append(node)
+                node = node.left
+            
+            node = stack.pop()
+            
+            prev.right = node
+            node.left = prev
+            
+            prev = node
+            
+            node = node.right
+        
+        head = preHead.right
+        head.left = prev
+        prev.right = head
+        
+        return head
+
+"""
+FYI
+"""
+def inOrderTraverse(root):
+    stack = []
+    node = root
+    
+    while node or stack:
+        while node:
+            stack.append(node)
+            node = node.left
+        
+        node = stack.pop()
+        
+        #do something
+        print node.val
+        
+        node = node.right

problems/largest-bst-subtree.py

@@ -0,0 +1,22 @@
+"""
+Time: O(N) for recursively traverse each node once.
+Space: O(LogN) for recursive stack.
+"""
+class Solution(object):
+    def largestBSTSubtree(self, root):
+        def helper(node, minVal, maxVal):
+            if not node: return True, 0, float('-inf'), float('inf')
+            if not node.left and not node.right: return True, 1, node.val, node.val
+            
+            isLeftBST, leftSize, leftMin, leftMax = helper(node.left, minVal, node.val)
+            isRightBST, rightSize, rightMin, rightMax = helper(node.right, node.val, maxVal)
+            
+            currMin = min(leftMin, rightMin, node.val)
+            currMax = max(leftMax, rightMax, node.val)
+            
+            if isLeftBST and isRightBST and leftMax<node.val and node.val<rightMin:
+                return True, 1+leftSize+rightSize, currMin, currMax
+            else:
+                return False, max(leftSize, rightSize), currMin, currMax
+            
+        return helper(root, float('-inf'), float('inf'))[1]