no message

Author: Chris Wu

problems/convert-sorted-array-to-binary-search-tree.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def sortedArrayToBST(self, nums):
+        if not nums: return None
+        
+        m = len(nums)/2
+        root = TreeNode(nums[m], self.sortedArrayToBST(nums[:m]), self.sortedArrayToBST(nums[m+1:]))
+        return root
+
+
+"""
+`nums` is a sorted array.
+To construct the most balanced BST, we must use the median number in `nums` as root.
+So the number of elements under left subtree and right subtree will be the same.
+
+Now we know which element in the `nums` will be root.
+For `root.left` we only need to consider `nums[:m]`.
+For `root.right` we only need to consider `nums[m+1:]`.
+Which needs to be a balanced BST, too. So we apply the same logic.
+
+Time: O(N). Because there will be N element being construct.
+Space: O(LogN). There will be LogN level of recursive call.
+"""

problems/delete-node-in-a-bst.py

@@ -0,0 +1,61 @@
+class Solution(object):
+    def deleteNode(self, root, key):
+        def find_min(root):
+            curr = root
+            while curr.left: curr = curr.left
+            return curr.val#[5]
+        
+        def remove(node):
+            if node.left and node.right:
+                node.val = find_min(node.right)
+                node.right = self.deleteNode(node.right, node.val)
+                return node #[4]
+            elif node.left and not node.right:
+                return node.left #[3]
+            elif node.right and not node.left:
+                return node.right #[3]
+            else:
+                return None #[2]
+            
+        if not root: return root
+        node = root
+        
+        while node: #[0]
+            if node.val==key:
+                return remove(node) #[1]
+            elif node.left and node.left.val==key:
+                node.left = remove(node.left) #[1]
+                return root
+            elif node.right and node.right.val==key:
+                node.right = remove(node.right) #[1]
+                return root
+            
+            if key>node.val and node.right:
+                node = node.right
+            elif key<node.val and node.left:
+                node = node.left
+            else:
+                break
+                
+        return root
+
+"""
+Find the parant and the node to be deleted. [0]
+Deleting the node means replacing its reference by something else. [1]
+
+For the node to be deleted, if it only has no child, just remove it from the parent. Return None. [2]
+
+If it has one child, return the child. So its parent will directly connect to its child. [3]
+
+If it has both child. Update the node's val to the minimum value in the right subtree. Remove the minimum value node in the right subtree. [4]
+This is equivalent to replacing the node by the minimum value node in the right subtree.
+Another option is to replace the node by the maximum value node in the left subtree.
+
+Find the minimum value in the left subtree is easy. The leftest node value in the tree is the smallest. [5]
+
+Time Complexity: O(LogN). O(LogN) for finding the node to be deleted.
+The recursive call in `remove()` will be apply to a much smaller subtree. And much smaller subtree...
+So can be ignored.
+Space complexity is O(LogN). Because the recursive call will at most be called LogN times.
+N is the number of nodes. And LogN can be consider the height of the tree.
+"""

problems/find-mode-in-binary-search-tree.py

@@ -0,0 +1,87 @@
+from collections import Counter
+class Solution(object):
+    def findMode(self, root):
+        def count(node):
+            counter[node.val] += 1
+            if node.left: count(node.left)
+            if node.right: count(node.right)
+        
+        if not root: return []
+        
+        counter = Counter()
+        count(root)
+        max_count = max(counter.values())
+        return [val for val, count in counter.items() if count==max_count]
+
+"""
+Time: O(N). For we traverse every node recursively.
+Space: O(N). Becuase we store all element's val and count in `counter`.
+Note that, we do not use the feature of BST.
+"""
+
+class Solution(object):
+    def findMode(self, root):
+        if not root: return []
+        
+        ans = []
+        stack = []
+        prev_val = None
+        curr = root
+        curr_count = 0
+        max_count = float('-inf')
+        
+        while curr or stack:
+            while curr:
+                stack.append(curr)
+                curr = curr.left
+            curr = stack.pop()
+            
+            #[0]
+            if curr.val!=prev_val:
+                curr_count = 1
+                prev_val = curr.val
+            else:
+                curr_count += 1
+            
+            #[1]
+            if curr_count>max_count:
+                ans = [curr.val]
+                max_count = curr_count
+            elif curr_count==max_count:
+                ans.append(curr.val)
+            
+            curr = curr.right
+                
+        return ans
+
+"""
+To use the feature of BST, we are going to inorder traverse the BST.
+So it will be like we are iterating a sorted array.
+
+[1]
+While iterating, we can put only the element count that is greater or equal than `max_count` to `ans`.
+If we encounter a new element with larger `curr_count`, we reset the `ans`.
+
+[0]
+With the help of `prev_val` we can know that `curr_node` is the same to the previous or not.
+If not, its a new element, we need to reset the `curr_count`.
+
+Time: O(N). Space: O(1)
+
+For better understanding, below is a template for inorder traverse.
+"""
+
+#inorder traversal of BST
+def inorder_traverse(root):
+    curr = root
+    stack = []
+    while curr or stack:
+        while curr:
+            stack.append(curr)
+            curr = curr.left
+        curr = stack.pop()
+        
+        #do something to the current node
+        print curr.val
+        
+        curr = curr.right