no message

Author: Chris Wu

problems/binary-tree-pruning.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def pruneTree(self, root):
+        def hasOne(node):
+            if not node: return False
+
+            left_has_one = hasOne(node.left)
+            right_has_one = hasOne(node.right)
+
+            if not left_has_one: node.left = None
+            if not right_has_one: node.right = None
+
+            return node.val==1 or left_has_one or right_has_one
+        
+        return root if hasOne(root) else None
+
+class Solution(object):
+    def pruneTree(self, node):
+        if not node: return None
+        node.left = self.pruneTree(node.left)
+        node.right = self.pruneTree(node.right)
+        if not node.left and not node.right and node.val==0: return None
+        return node
+
+"""
+Time complexity is O(N). Because we traverse all the nodes.
+Space complexity is O(LogN). The tree's height is about O(LogN), so we have O(LogN) level of recursion and used up O(LogN) of stack memory
+"""

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

@@ -1,28 +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`.
+And maintain `min_x`, `max_x` 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
+        min_x = 0
+        max_x = 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)
+            min_x = min(min_x, x)
+            max_x = max(max_x, 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):
+        for i in range(min_x, max_x+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