no message

Author: Chris Wu

.gitignore

@@ -1 +1,2 @@
-_doc/*
+_doc/*
+.vscode

problems/binary-tree-pruning.py

@@ -23,5 +23,5 @@ def pruneTree(self, 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
+Space complexity is O(N). In the worst case, the recursion will go O(N) level deep.
 """

problems/path-sum-ii.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def pathSum(self, root, S):
+        if not root: return False
+        
+        opt = []
+        stack = []
+        stack.append((root, 0, []))
+        
+        while stack:
+            node, s, path = stack.pop()
+            s += node.val
+            path = path + [node.val]
+            if not node.left and not node.right and s==S: opt.append(path)
+            if node.left: stack.append((node.left, s, path))
+            if node.right: stack.append((node.right, s, path))
+        return opt
+"""
+Time complexity is O(N), because we traverse all the nodes.
+Space complexity is O(N^2), because in the worst case, all node could carry all the other nodes in the `path`.
+"""

problems/path-sum.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def hasPathSum(self, root, S):
+        if not root: return False
+        
+        stack = []
+        stack.append((root, 0))
+        
+        while stack:
+            node, s = stack.pop()
+            s += node.val
+            if not node.left and not node.right and s==S: return True
+            if node.left: stack.append((node.left, s))
+            if node.right: stack.append((node.right, s))
+        return False

problems/trim-a-binary-search-tree.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def trimBST(self, root, L, R):
+        if not root: return root
+        root.left = self.trimBST(root.left, L, R)
+        root.right = self.trimBST(root.right, L, R)
+        return root if L<=root.val and root.val<=R else root.left or root.right
+
+"""
+First, trim left child and right child.
+Second, if the root is in range, return the root.
+if not, return the trimed left child.
+if not trimed left child, return the trimed right child.
+if both left and right child is None, it will return None anyway.
+
+Time complexity is O(N). For we simply just traverse all the nodes.
+Space complexity is O(N). In the worst case, the recursion will go O(N) level deep.
+"""