no message

Author: wuduhren

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

@@ -1,3 +1,23 @@
+"""
+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.
+"""
 class Solution(object):
     def deleteNode(self, root, key):
         def find_min(root):
@@ -39,23 +59,41 @@ def remove(node):
 
         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.
+class Solution(object):
+    def deleteNode(self, node, key):
+        if not node:
+            return node
+        elif key<node.val:
+            node.left = self.deleteNode(node.left, key)
+            return node
+        elif key>node.val:
+            node.right = self.deleteNode(node.right, key)
+            return node
+        elif key==node.val:
+            if not node.left and not node.right:
+                return None
+            elif not node.left:
+                return node.right
+            elif not node.right:
+                return node.left
+            else:
+                node.val = self.findMin(node.right) #min value in the right subtree
+                node.right = self.deleteNode(node.right, node.val)
+                return node
+        
+    def findMin(self, root):
+        ans = float('inf')
+        stack = [root]
+
+        while stack:
+            node = stack.pop()
+            ans = min(ans, node.val)
+            if node.left: stack.append(node.left)
+            if node.right: stack.append(node.right)
+        return ans
+
 
-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/minimum-absolute-difference-in-bst.py

@@ -43,4 +43,47 @@ def traverse(node):
 """
 Time complexity: O(N)
 Space complexity: O(N)
-"""
+"""
+
+
+"""
+Inorder traverse the BST and update the diff.
+Time complexity: O(N)
+Space complexity: O(N)
+"""
+class Solution(object):
+    def getMinimumDifference(self, root):
+        ans = float('inf')
+        
+        stack = []
+        curr = root
+        prevVal = float('-inf')
+        
+        while stack or curr:
+            while curr:
+                stack.append(curr)
+                curr = curr.left
+                
+            curr = stack.pop()
+            ans = min(ans, curr.val-prevVal)
+            prevVal = curr.val
+            
+            curr = curr.right
+        return ans
+
+
+def inorderTraversal(self, root):
+    stack = []
+    curr = root
+    
+    while stack or curr:
+        while curr:
+            stack.append(curr)
+            curr = curr.left
+            
+        curr = stack.pop()
+        
+        # do something
+        print curr.val
+        
+        curr = curr.right

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

@@ -1,3 +1,7 @@
+"""
+Time complexity: O(LogN)
+Space complexity: O(1)
+"""
 class Solution(object):
     def searchBST(self, root, val):
         node = root
@@ -12,8 +16,16 @@ def searchBST(self, root, val):
 
         return None
 
-
 """
 Time complexity: O(LogN)
-Space complexity: O(1)
-"""
+Space complexity: O(LogN)
+"""
+class Solution(object):
+    def searchBST(self, node, val):
+        if not node: return None
+        if node.val==val:
+            return node
+        elif node.val<val:
+            return self.searchBST(node.right, val)
+        elif node.val>val:
+            return self.searchBST(node.left, val)