no message

Author: chris

binary-tree-right-side-view.py

@@ -0,0 +1,31 @@
+"""
+perform BFS to the tree:
+we traverse every node in the level then go to the next level
+every level we traverse from right to left
+if it is a level we haven't been through before
+we add the node's val to the output
+
+time efficiency is O(N)
+because we basically go through all the nodes
+N is the total nodes count
+
+space efficiency is O(N)
+since we my store the whole level of the tree in the queue
+the last level is 0.5N
+N is the total nodes count
+"""
+from collections import deque
+class Solution(object):
+    def rightSideView(self, root):
+        queue = deque([(root, 0)])
+        max_level = -1
+        view = []
+        while queue:
+            node, level = queue.popleft()
+            if node==None: continue
+            if level>max_level:
+                max_level = level
+                view.append(node.val)
+            queue.append((node.right, level+1))
+            queue.append((node.left, level+1))
+        return view

maximum-subarray.py

@@ -1,14 +1,22 @@
 #https://leetcode.com/problems/maximum-subarray/
+"""
+[0]
+if we know the max value of the subarray that ends at i index is Mi
+what is the max value of the subarray that ends at i+1 index?
+its either nums[i+1] or nums[i+1]+Mi
+so code below, maxCurrent[i] stores the max value of subarray that ends at i
+
+[1]
+the max value of the subarray that ends at 0, has to be nums[0].
+
+[2]
+the max value of subarray must ends in one of the index of nums
+so we get the max(maxCurrent).
+"""
 class Solution(object):
     def maxSubArray(self, nums):
-        maxCurrent = []
-        for i in range(0, len(nums)):
-            n = nums[i]
-            if (i==0):
-                maxCurrent.append(n)
-            else:
-                if (n>n+maxCurrent[i-1]):
-                    maxCurrent.append(n)
-                else:
-                    maxCurrent.append(n+maxCurrent[i-1])
-        return max(maxCurrent)
+        if nums==None or len(nums)==0: return None
+        maxCurrent = [nums[0]] #[1]
+        for i in xrange(1, len(nums)):
+            maxCurrent.append(max(nums[i], nums[i]+maxCurrent[-1])) #[0]
+        return max(maxCurrent) #[2]

search-in-rotated-sorted-array.py

@@ -69,4 +69,6 @@ def search(self, nums, target):
                 #l~m is not sorted
                 #check l~m-1
                 r = m-1
-                continue
+                continue
+
+            return -1

validate-binary-search-tree.py

@@ -0,0 +1,74 @@
+"""
+1.
+for recursive/iterative solution
+if you are a left node
+your max will be your parent's value
+your min will be yout parent's min, because your parent might be someone's right child.
+
+if you are a right node
+your min will be your parent's value
+your max will be your parent's max, because your parent might be someone's left child.
+
+root have no max and min
+
+2.
+for in-order traversal solution
+if you use in-order to traverse a BST
+the value you list out will be in order(sorted)
+so each element would be greater than the last one
+
+in-order traverse:
+left child -> current node -> right child
+
+normaly I will recursivly do the in-order traversing
+but iterative is easier to track the last element'value
+
+3. I personally like in-order traversal solution
+"""
+class Solution(object):
+	#recursive
+    def isValidBST(self, root):
+        def helper(node, min_val, max_val):
+            if node==None:
+                return True
+            if node.val<=min_val or node.val>=max_val:
+                return False
+            
+            left_valid = helper(node.left, min_val, node.val)
+            if not left_valid: return False
+            right_valid = helper(node.right, node.val, max_val)
+            if not right_valid: return False
+            
+            return True
+        return helper(root, float('-inf'), float('inf'))
+
+    #iterative
+    def isValidBST(self, root):
+        if root==None: return True
+        stack = [(root, float('-inf'), float('inf'))]
+        while stack:
+            node, min_val, max_val = stack.pop()
+            if node.val<=min_val or node.val>=max_val:
+                return False
+            if node.left:
+                stack.append((node.left, min_val, node.val))
+            if node.right:
+                stack.append((node.right, node.val, max_val))
+        return True
+   	        
+    #in-order traversal
+    def isValidBST(self, root):
+        stack = []
+        last_val = float('-inf')
+        while root or stack:
+            while root:
+                stack.append(root)
+                root = root.left
+            root = stack.pop()
+
+            if root.val<=last_val:
+                return False
+            
+            last_val = root.val
+            root = root.right #if root.right: root = root.right
+        return True