no message

Author: wuduhren

problems/backspace-string-compare.py

@@ -82,4 +82,24 @@ def backspaceCompare(self, s1, s2):
             j -= 1
 
         return True
-        
+
+
+class Solution(object):
+    def backspaceCompare(self, s, t):
+        def helper(S):
+            ans = ''
+            i = len(S)-1
+            backspaceCount = 0
+            
+            while i>=0:
+                if S[i]=='#':
+                    backspaceCount += 1
+                else:
+                    if backspaceCount>0:
+                        backspaceCount -= 1
+                    else:
+                        ans += S[i]
+                i -= 1
+            return ans
+        
+        return helper(s)==helper(t)

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

@@ -0,0 +1,36 @@
+"""
+Imagine a list of sorted nodes, if we wanted to use the nodes to form a balanced BST, which root should we use?
+Yes, the one in the middle, since it can evenly spread two groups of nodes. This is what `getRoot()` does.
+And we do the same for the left half and right half. And so on. And so on...
+
+Time: O(N), N is the number of nodes.
+Space: O(N)
+"""
+class Solution(object):
+    def balanceBST(self, root):
+        def getInorderNodes(root):
+            nodes = []
+            stack = []
+            node = root
+            
+            while node or stack:
+                while node:
+                    stack.append(node)
+                    node = node.left
+                
+                node = stack.pop()
+                nodes.append(node)
+                node = node.right
+            
+            return nodes
+                
+        def getRoot(l, r):
+            if l>r: return None
+            m = (l+r)/2
+            root = inorderNodes[m]
+            root.left = getRoot(l, m-1)
+            root.right = getRoot(m+1, r)
+            return root
+            
+        inorderNodes = getInorderNodes(root)
+        return getRoot(0, len(inorderNodes)-1)

problems/binary-search-tree-iterator.py

@@ -61,4 +61,28 @@ def inOrderTraverse(root):
         #do something
         print node.val
 
-        node = node.right
+        node = node.right
+
+
+
+class BSTIterator(object):
+
+    def __init__(self, root):
+        self.stack = []
+        self.node = root
+        
+        
+
+    def next(self):
+        while self.node:
+            self.stack.append(self.node)
+            self.node = self.node.left
+        self.node = self.stack.pop()
+        returnVal = self.node.val
+        self.node = self.node.right
+        return returnVal
+        
+        
+
+    def hasNext(self):
+        return self.node or self.stack

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

@@ -24,4 +24,27 @@ def verticalOrder(self, root):
             if node.left: q.append((node.left, x-1))
             if node.right: q.append((node.right, x+1))
 
-        return [ans[x] for x in xrange(minX, maxX+1)]
+        return [ans[x] for x in xrange(minX, maxX+1)]
+
+
+class Solution(object):
+    def verticalOrder(self, root):
+        if not root: return []
+        ans = []
+        minX = float('inf')
+        maxX = float('-inf')
+        locations = collections.defaultdict(list)
+        q = collections.deque([(root, 0)])
+        
+        while q:
+            node, x = q.popleft()
+            locations[x].append(node.val)
+            minX = min(minX, x)
+            maxX = max(maxX, x)
+            if node.left: q.append((node.left, x-1))
+            if node.right: q.append((node.right, x+1))
+        
+        for x in xrange(minX, maxX+1):
+            if locations[x]: ans.append(locations[x])
+                
+        return ans

problems/convert-binary-search-tree-to-sorted-doubly-linked-list.py

@@ -101,4 +101,6 @@ def inOrderTraverse(root):
         #do something
         print node.val
 
-        node = node.right
+        node = node.right
+
+ 

problems/copy-list-with-random-pointer.py

@@ -55,5 +55,38 @@ def copyRandomList(self, head):
 
 """
 Time: O(N). Two iteration. First iteration make a the clones. Second iteration setup the links.
-Space: O(1). No extra space except the cloned node.
-"""
+Space: O(N).
+"""
+
+
+"""
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def copyRandomList(self, head):
+        if not head: return head
+        curr = head
+        while curr:
+            nextCurr = curr.next
+            copy = Node(curr.val)
+            curr.next = copy
+            copy.next = nextCurr
+            curr = nextCurr
+        
+        copyHead = head.next
+
+        curr = head
+        while curr:
+            if curr.random: curr.next.random = curr.random.next
+            curr = curr.next.next
+        
+        curr = head
+        while curr:
+            nextCurr = curr.next.next
+            if nextCurr:
+                curr.next.next = nextCurr.next
+            curr.next = nextCurr
+            curr = nextCurr
+        
+        return copyHead

problems/diameter-of-binary-tree.py

@@ -83,3 +83,23 @@ def getMaxDepth(node):
 
 #         return ans
 
+
+"""
+For each route in the binary tree, we can view it from the highest node in the route.
+So the length will be helper(node.left) + 1 + helper(node.right).
+"""
+class Solution(object):
+    def __init__(self):
+        self.ans = 0 #number of nodes in the longest route
+        
+    def diameterOfBinaryTree(self, root):
+	    #return the longest length to the leaf including itself
+        #also update self.ans
+        def helper(node):
+            r = helper(node.right) if node.right else 0
+            l = helper(node.left) if node.left else 0
+            self.ans = max(self.ans, l+1+r)
+            return max(l+1, r+1)
+        
+        helper(root)
+        return self.ans-1

problems/find-distance-in-a-binary-tree.py

@@ -0,0 +1,28 @@
+class Solution(object):
+    def __init__(self):
+        self.lca = None
+        self.pHeight = 0
+        self.qHeight = 0
+        
+    def findDistance(self, root, p, q):
+        #find the count of p or q in node's subtree, set the first node we found that has count>=2 as lca.
+        def findCount(node):
+            if not node: return 0
+            count = 0
+            if node.val==p or node.val==q: count += 1
+            count += findPQCount(node.left)
+            count += findPQCount(node.right)
+            if count>=2 and not self.lca: self.lca = node
+            return count
+        
+        def findHeight(node, h):
+            if not node: return
+            if node.val==p: self.pHeight = h
+            if node.val==q: self.qHeight = h
+            if self.pHeight and self.qHeight: return
+            findHeight(node.left, h+1)
+            findHeight(node.right, h+1)
+            
+        findCount(root)
+        findHeight(self.lca, 0)
+        return self.qHeight + self.pHeight

problems/find-duplicate-subtrees.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def findDuplicateSubtrees(self, root):
+        def dfs(node):
+            if not node: return '#'
+            string = str(node.val) + ',' + dfs(node.left) + ',' + dfs(node.right)
+            data[string].append(node)
+            return string
+        
+        data = collections.defaultdict(list)
+        ans = []
+        
+        dfs(root)
+        
+        for s in data:
+            if len(data[s])>=2: ans.append(data[s][0])
+        return ans

problems/find-k-closest-elements.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def findClosestElements(self, arr, K, X):
+        def isCloserThan(n1, n2, x):
+            return abs(x-n1)<abs(x-n2) or (abs(x-n1)==abs(x-n2) and n1<n2)
+                
+        output1 = []
+        output2 = []
+        
+        r = bisect.bisect_left(arr, X)
+        l = r-1
+        
+        while len(output1)+len(output2)<K:
+            if r>=len(arr) or (l>=0 and isCloserThan(arr[l], arr[r], X)):
+                output1.append(arr[l])
+                l -= 1
+            else:
+                output2.append(arr[r])
+                r += 1
+        
+        return output1[::-1]+output2