no message

Author: wuduhren

problems/binary-search-tree-iterator.py

@@ -1,10 +1,3 @@
-# Definition for a binary tree node.
-# class TreeNode(object):
-#     def __init__(self, x):
-#         self.val = x
-#         self.left = None
-#         self.right = None
-
 class BSTIterator(object):
 
     def __init__(self, root):
@@ -27,10 +20,45 @@ def next(self):
 
     def hasNext(self):
         return len(self.stack)!=0
+
+"""
+Time: init() O(1). next() O(LogN). hasNext() O(1).
+Space: O(N)
+"""   
+class BSTIterator(object):
+
+    def __init__(self, root):
+        self.node = root
+        self.stack = []
+            
+    def next(self):
+        while self.node:
+            self.stack.append(self.node)
+            self.node = self.node.left
+            
+        node = self.stack.pop()
+        self.node = node.right
+        return node.val
 
+    def hasNext(self):
+        return self.stack or self.node
 
 
-# Your BSTIterator object will be instantiated and called as such:
-# obj = BSTIterator(root)
-# param_1 = obj.next()
-# param_2 = obj.hasNext()
+"""
+FYI. Template for in-order traverse.
+"""
+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/binary-tree-right-side-view.py

@@ -28,4 +28,28 @@ def rightSideView(self, root):
                 view.append(node.val)
             queue.append((node.right, level+1))
             queue.append((node.left, level+1))
-        return view
+        return view
+
+"""
+Time: O(N).
+Space: O(N).
+
+Similar solution using DFS.
+"""
+class Solution(object):
+    def rightSideView(self, root):
+        if not root: return []
+        
+        ans = []
+        currLevel = -1
+        stack = [(root, 0)]
+        
+        while stack:
+            node, level = stack.pop()
+            if level>currLevel:
+                ans.append(node.val)
+                currLevel = level
+            if node.left: stack.append((node.left, level+1))
+            if node.right: stack.append((node.right, level+1))
+                
+        return ans

problems/lowest-common-ancestor-of-a-binary-search-tree.py

@@ -0,0 +1,19 @@
+"""
+Time: O(LogN). O(N) if the tree is unbalanced.
+Space: O(1)
+
+If both p and q are both on the left subtree, then search the left subtree.
+If both p and q are both on the right subtree, then search the right subtree.
+Else the current must be the ans.
+"""
+class Solution(object):
+    def lowestCommonAncestor(self, root, p, q):
+        node = root
+        
+        while node:
+            if node.val>q.val and node.val>p.val:
+                node = node.left
+            elif node.val<q.val and node.val<p.val:
+                node = node.right
+            else:
+                return node

problems/lowest-common-ancestor-of-a-binary-tree.py

@@ -129,4 +129,25 @@ def find_lowest_common(a1, a2):
 find_ancestors() is O(LogN).
 find_lowest_common is O(LogN).
 Space complexity is O(N), since `genealogy` may carry all the nodes.
-"""
+"""
+
+
+# 2021/9/25
+class Solution(object):
+    def lowestCommonAncestor(self, root, p, q):
+        def __init__(self):
+            self.ans = None
+            
+        def helper(node):
+            
+            if not node: return False
+            mid = node==q or node==p
+            left = helper(node.left)
+            right = helper(node.right)
+            
+            if (mid and left) or (mid and right) or (left and right): self.ans = node
+            
+            return mid or left or right
+        
+        helper(root)
+        return self.ans