Merge branch 'master' of https://github.com/yuzhoujr/LeetCode

Author: tech-cow

tree/113. Path Sum II - EricD.py

@@ -0,0 +1,31 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def helper(self, node, num, path, res):
+        left = num - node.val
+        if left == 0 and (not node.left) and (not node.right):
+            res.append(path+[node.val])
+        elif (not node.left) and (not node.right):
+            return
+        else:
+            if node.left: self.helper(node.left, left, path+[node.val],res)
+            if node.right: self.helper(node.right, left, path+[node.val], res)
+    
+    def pathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        path,res = [],[]
+        self.helper(root, sum, path, res)
+        return res
+
+        

tree/145. Binary Tree Postorder Traversal - EricD.py

@@ -0,0 +1,19 @@
+def postorderTraversal(self, root):
+    """
+    :type root: TreeNode
+    :rtype: List[int]
+    """
+    res,stack = [],[]
+    while root:
+        res.append(root.val)
+        stack.append(root)
+        root = root.right
+    while stack:
+        tmp = stack.pop()
+        if tmp.left:
+            t = tmp.left
+            while t:
+                res.append(t.val)
+                stack.append(t)
+                t = t.right
+    return res[::-1]

tree/173. Binary Search Tree Iterator - EricD.py

@@ -0,0 +1,42 @@
+# Definition for a  binary tree node
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class BSTIterator(object):
+    def __init__(self, root):
+        """
+        :type root: TreeNode
+        """
+        self.list = []
+        self.inOrder(root)
+        self.i = 0
+        
+    def inOrder(self,node):
+        if not node:
+            return
+        self.inOrder(node.left)
+        self.list.append(node.val)
+        self.inOrder(node.right)
+        
+
+    def hasNext(self):
+        """
+        :rtype: bool
+        """
+        return self.i < len(self.list)
+        
+
+    def next(self):
+        """
+        :rtype: int
+        """
+        self.i+=1
+        return self.list[self.i-1]
+        
+
+# Your BSTIterator will be called like this:
+# i, v = BSTIterator(root), []
+# while i.hasNext(): v.append(i.next())

tree/543. Diameter of Binary Tree - EricD.py

@@ -0,0 +1,18 @@
+def helper(self,node,res):
+    if not node:
+        return 0
+    l = self.helper(node.left,res)
+    r = self.helper(node.right,res)
+    res[0] = max(res[0],l+r)
+    return 1+max(l,r)
+
+def diameterOfBinaryTree(self, root):
+    """
+    :type root: TreeNode
+    :rtype: int
+    """
+    if not root:
+        return 0
+    res = [0]
+    self.helper(root,res)
+    return res[0]

tree/94. Binary Tree Inorder Traversal - EricD.py

@@ -0,0 +1,21 @@
+def inorderTraversal(self, root):
+    """
+    :type root: TreeNode
+    :rtype: List[int]
+    """
+    res = []
+    stack = []
+    while root:
+    	stack.append(root)
+    	root = root.left
+    
+    while stack:
+    	tmp = stack.pop()
+    	res.append(tmp.val)
+    	if tmp.right:
+    		t = tmp.right
+    		#add all left
+    		while t:
+    			stack.append(t)
+    			t = t.left
+    return res

tree/Ying/100_SameTree.py

@@ -0,0 +1,29 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSameTree(self, p, q):
+        """
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: bool
+        """
+        if not p and not q:
+            return True
+        
+        return self.isSameTreeHelper(p, q)
+        
+    def isSameTreeHelper(self, p, q):
+        
+        if not p and not q:
+            return True
+            
+        if (not p and q) or (not q and p):
+            return False
+        
+        
+        return p.val==q.val and self.isSameTreeHelper(p.left, q.left) and self.isSameTreeHelper(p.right, q.right)

tree/Ying/101_SymmetricTree.py

@@ -0,0 +1,36 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSymmetric(self, root):
+        
+        if not root:
+            return True
+        
+        return self.compareTree(root.left, root.right)
+        
+        
+    
+    def compareTree(self, left, right):
+        
+        if not left and not right:
+            return True
+            
+        
+    
+        
+        if (not left and right) or  (not right and left):
+            return False
+        
+            
+        
+            
+        return left.val==right.val and self.compareTree(left.left, right.right) and self.compareTree(left.right, right.left)
+        
+        
+        
+    

tree/Ying/104_MaxDepth.py

@@ -0,0 +1,20 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if root is None:
+            return 0
+            
+        elif root.left is None and root.right is None:
+            return 1
+        else:
+            return max(self.maxDepth(root.left),self.maxDepth(root.right))+1

tree/Ying/111_MinDepth.py

@@ -0,0 +1,38 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def minDepth(self, root):
+        """a
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+            
+        return self.minDepthHelper(root)
+    
+    def minDepthHelper(self, root):
+        
+        
+        
+        if not root:
+            return 0
+         
+        
+        if not root.left and not root.right:
+            return 1
+        
+        left = self.minDepthHelper(root.left)
+        right = self.minDepthHelper(root.right)
+        
+        return max(left,right )+1 if left==0 or right==0 else min(left, right)+1
+        
+        
+        
+        
+    

tree/Ying/235_LCA.py

@@ -0,0 +1,37 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def lowestCommonAncestor(self, root, p, q):
+        """
+        :type root: TreeNode
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: TreeNode
+        """
+        if not root or not p or not q:
+            return root
+        
+        maxval = max(p.val, q.val)
+        minval = min(p.val, q.val)
+        
+        while root:
+            
+            if minval<=root.val<=maxval:
+                return root
+                
+            elif root.val>maxval:
+                root = root.left
+            
+            elif root.val<minval:
+                root = root.right
+                
+            
+        
+        return root
+          
+        

tree/Yu/104_maxDepth.py

@@ -20,3 +20,17 @@ def maxDepth(self, root):
           return 0
       else:
           return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
+
+        
+# ********************
+# Divide and Conquer *
+# ********************        
+class Solution(object):
+    def maxDepth(self, root):
+        if not root:
+            return 0
+        else:
+            # using Divide and Conquer
+            left = self.maxDepth(root.left)
+            right = self.maxDepth(root.right)
+            return max(left, right) + 1