no message

Author: Chris Wu

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

@@ -0,0 +1,20 @@
+from collections import deque
+
+class Solution(object):
+    def levelOrderBottom(self, root):
+        opt = []
+
+        if not root: return opt
+
+        q = deque()
+        q.append((root, 0))
+
+        while q:
+            node, depth = q.popleft()
+            if depth<len(opt):
+                opt[depth].append(node.val)
+            else:
+                opt.append([node.val])
+            if node.left: q.append((node.left, depth+1))
+            if node.right: q.append((node.right, depth+1))
+        return reversed(opt)

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

@@ -0,0 +1,25 @@
+from collections import deque
+
+class Solution(object):
+    def levelOrder(self, root):
+        opt = []
+
+        if not root: return opt
+
+        q = deque()
+        q.append((root, 0))
+
+        while q:
+            node, depth = q.popleft()
+            if depth<len(opt):
+                opt[depth].append(node.val)
+            else:
+                opt.append([node.val])
+            if node.left: q.append((node.left, depth+1))
+            if node.right: q.append((node.right, depth+1))
+        return opt
+
+"""
+Time complexity is O(N). Because we perform a BFS, where N is the number of nodes. (We traverse all the nodes in the tree)
+Time complexity is O(N), too. Because we might potentially store all the nodes in the queue.
+"""

problems/n-ary-tree-level-order-traversal.py

@@ -0,0 +1,26 @@
+from collections import deque
+
+class Solution(object):
+    def levelOrder(self, root):
+        opt = []
+
+        if not root: return opt
+
+        q = deque()
+        q.append((root, 0))
+
+        while q:
+            node, depth = q.popleft()
+            if depth<len(opt):
+                opt[depth].append(node.val)
+            else:
+                opt.append([node.val])
+            if node.children:
+                for child in node.children:
+                    q.append((child, depth+1))
+        return opt
+
+"""
+Time complexity is O(N). Because we perform a BFS, where N is the number of nodes. (We traverse all the nodes in the tree)
+Time complexity is O(N), too. Because we might potentially store all the nodes in the queue.
+"""

problems/univalued-binary-tree.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def isUnivalTree(self, root):
+        stack = []
+        stack.append(root)
+        value = root.val
+        while stack:
+            node = stack.pop()
+            if node.val!=value: return False
+            if node.left: stack.append(node.left)
+            if node.right: stack.append(node.right)
+        return True

problems/vertical-order-traversal-of-a-binary-tree.py

@@ -0,0 +1,28 @@
+"""
+The description wants us to report from left to right, top to bottom.
+Thus, we keep add value into `temp` with `x_position` as the key and `(y_position, node.val)` as the value.
+And maintain `min_index`, `max_index` at the same time. So we know how to iterate the `temp`.
+"""
+from collections import defaultdict
+
+class Solution(object):
+    def verticalTraversal(self, root):
+        temp = defaultdict(list)
+        min_index = 0
+        max_index = 0
+
+        stack = []
+        stack.append((root, 0, 0))
+        while stack:
+            node, x, y = stack.pop()
+            temp[x].append((y, node.val)) #append the value of height, so we can sort by height later on
+            min_index = min(min_index, x)
+            max_index = max(max_index, x)
+            if node.left: stack.append((node.left, x-1, y+1))
+            if node.right: stack.append((node.right, x+1, y+1))
+        
+        opt = []
+        for i in range(min_index, max_index+1):
+            opt.append([v for y, v in sorted(temp[i])]) #the temp[i] will be sorted by y_position then sorted by node.val
+        
+        return opt