no message

Author: wuduhren

problems/python3/binary-tree-level-order-traversal.py

@@ -0,0 +1,39 @@
+"""
+Time: O(N), since we need to go through all the nodes.
+Space: O(LogN) for recursion stack. (if the tree is balanced). This do not take the output into account.
+"""
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        def helper(node, level):
+            if not node: return
+            if level==len(ans): ans.append([])
+            ans[level].append(node.val)
+            helper(node.left, level+1)
+            helper(node.right, level+1)
+        
+        ans = []
+        helper(root, 0)
+        
+        return ans
+
+
+"""
+Time: O(N), since we need to go through all the nodes.
+Space: O(N) for queue.
+"""
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root: return []
+        
+        q = collections.deque([(root, 0)])
+        ans = []
+        
+        while q:
+            node, level = q.popleft()
+            
+            if level==len(ans): ans.append([])
+            ans[level].append(node.val)
+            if node.left: q.append((node.left, level+1))
+            if node.right: q.append((node.right, level+1))
+        
+        return ans

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

@@ -0,0 +1,28 @@
+"""
+Recursive
+Time: O(LogN) if the tree is balanced.
+Space: O(LogN) for the recursion stack.
+"""
+class Solution:
+    def lowestCommonAncestor(self, node: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if q.val<=node.val<=p.val or p.val<=node.val<=q.val:
+            return node
+        elif q.val<node.val and p.val<node.val:
+            return self.lowestCommonAncestor(node.left, p, q)
+        elif node.val<q.val and node.val<p.val:
+            return self.lowestCommonAncestor(node.right, p, q)
+
+
+"""
+Iterative
+Time: O(LogN) if the tree is balanced.
+Space: O(1).
+"""
+class Solution:
+    def lowestCommonAncestor(self, node: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        while not (q.val<=node.val<=p.val or p.val<=node.val<=q.val):
+            if q.val<node.val and p.val<node.val:
+                node = node.left
+            elif node.val<q.val and node.val<p.val:
+                node = node.right
+        return node

problems/python3/same-tree.py

@@ -0,0 +1,16 @@
+"""
+Time: O(N)
+Space: O(LogN) if the tree is balanced.
+"""
+class Solution:
+    def isSameTree(self, node1: Optional[TreeNode], node2: Optional[TreeNode]) -> bool:
+        if not node1 and not node2:
+            return True
+
+        if (not node1 and node2) or (node1 and not node2):
+            return False
+
+        if node1.val!=node2.val:
+            return False
+
+        return self.isSameTree(node1.left, node2.left) and self.isSameTree(node1.right, node2.right)

problems/python3/subtree-of-another-tree.py

@@ -0,0 +1,10 @@
+class Solution:
+    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
+        if not root or not subRoot: return root==subRoot
+        if self.isSame(root, subRoot): return True
+        return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)
+        
+    def isSame(self, p, q):
+        if not p or not q: return p==q
+        if p.val!=q.val: return False
+        return self.isSame(p.left, q.left) and self.isSame(p.right, q.right)