update at 2018-04-02

Author: bonfy

101-symmetric-tree/symmetric-tree.py

@@ -0,0 +1,56 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
+#
+#
+# For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
+#
+#     1
+#    / \
+#   2   2
+#  / \ / \
+# 3  4 4  3
+#
+#
+#
+# But the following [1,2,2,null,3,null,3]  is not:
+#
+#     1
+#    / \
+#   2   2
+#    \   \
+#    3    3
+#
+#
+#
+#
+# Note:
+# Bonus points if you could solve it both recursively and iteratively.
+#
+
+
+# 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):
+        """
+        :type root: TreeNode
+        :rtype: bool
+        """
+        return self.helper(root,root)
+    
+    def helper(self,root1,root2):
+        if not root1 and not root2:
+            return True
+        if not root1 or not root2:
+            return False
+        if root1.val != root2.val:
+            return False
+        return self.helper(root1.left,root2.right) and self.helper(root1.right,root2.left)
+        return res

104-maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.py

@@ -0,0 +1,40 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a binary tree, find its maximum depth.
+#
+# The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+#
+# For example:
+# Given binary tree [3,9,20,null,null,15,7],
+#
+#
+#     3
+#    / \
+#   9  20
+#     /  \
+#    15   7
+#
+# return its depth = 3.
+#
+
+
+# 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 not root:
+            return 0
+        # if root.left == None and root.right == None:
+        #    return 1
+        else:
+            return max(self.maxDepth(root.left), self.maxDepth(root.right))+1

107-binary-tree-level-order-traversal-ii/binary-tree-level-order-traversal-ii.py

@@ -0,0 +1,63 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+#
+#
+# For example:
+# Given binary tree [3,9,20,null,null,15,7],
+#
+#     3
+#    / \
+#   9  20
+#     /  \
+#    15   7
+#
+#
+#
+# return its bottom-up level order traversal as:
+#
+# [
+#   [15,7],
+#   [9,20],
+#   [3]
+# ]
+#
+#
+
+
+# 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):
+    rlst = []
+
+    def levelOrderBottom(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        self.rlst=[]
+        self.levelList(root, 0)
+        mx = max([item['hight'] for item in self.rlst])
+        rst = [list() for _ in range(mx+1)]
+        for item in self.rlst:
+            rst[mx - item['hight']].append(item['val'])
+
+        return rst
+
+    def levelList(self, root, hight):
+        if root:
+            self.rlst.append({'val': root.val, 'hight': hight})
+            hight = hight + 1
+            if root.left:
+                self.levelList(root.left, hight)
+            if root.right:
+                self.levelList(root.right, hight)
+

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

@@ -0,0 +1,48 @@
+# -*- coding:utf-8 -*-
+
+
+# Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
+#
+# For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
+#
+#
+#
+#
+# Example:
+#
+# Given the sorted array: [-10,-3,0,5,9],
+#
+# One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
+#
+#       0
+#      / \
+#    -3   9
+#    /   /
+#  -10  5
+#
+#
+
+
+# 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 sortedArrayToBST(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: TreeNode
+        """
+        if not nums:
+            return None
+
+        mid = len(nums) // 2
+        
+        root = TreeNode(nums[mid])
+        root.left = self.sortedArrayToBST(nums[:mid])
+        root.right = self.sortedArrayToBST(nums[mid+1:])
+        
+        return root

111-minimum-depth-of-binary-tree/minimum-depth-of-binary-tree.py

@@ -0,0 +1,26 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a binary tree, find its minimum depth.
+#
+# The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
+
+
+# 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):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if root == None:
+            return 0
+        if root.left==None or root.right==None:
+            return self.minDepth(root.left)+self.minDepth(root.right)+1
+        return min(self.minDepth(root.right),self.minDepth(root.left))+1

112-path-sum/path-sum.py

@@ -0,0 +1,51 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
+#
+# For example:
+# Given the below binary tree and sum = 22,
+#
+#
+#               5
+#              / \
+#             4   8
+#            /   / \
+#           11  13  4
+#          /  \      \
+#         7    2      1
+#
+#
+# return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+#
+
+
+# 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 hasPathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: bool
+        """
+        if not root:
+            return False
+
+        stack = [(root, sum)]
+        while stack:
+            node, sum = stack.pop()
+            if not node.left and not node.right and node.val == sum:
+                return True
+            
+            if node.left:
+                stack.append((node.left, sum-node.val))
+            if node.right:
+                stack.append((node.right, sum-node.val))
+            
+        return False

113-path-sum-ii/path-sum-ii.py

@@ -0,0 +1,61 @@
+# -*- coding:utf-8 -*-
+
+
+#
+# Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
+#
+#
+# For example:
+# Given the below binary tree and sum = 22,
+#
+#               5
+#              / \
+#             4   8
+#            /   / \
+#           11  13  4
+#          /  \    / \
+#         7    2  5   1
+#
+#
+#
+# return
+#
+# [
+#    [5,4,11,2],
+#    [5,8,4,5]
+# ]
+#
+#
+
+
+# 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 pathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        
+        if not root.left and not root.right and root.val == sum:
+            return [[root.val]]
+        
+        r_left = []
+        r_right = []
+        
+        if root.left:
+            r_left = [[root.val] + l for l in self.pathSum(root.left, sum-root.val)]
+            
+        if root.right:
+            r_right = [[root.val] + l for l in self.pathSum(root.right, sum-root.val)]
+        
+        return r_left + r_right
+        

118-pascals-triangle/pascals-triangle.py

@@ -0,0 +1,38 @@
+# -*- coding:utf-8 -*-
+
+
+# Given numRows, generate the first numRows of Pascal's triangle.
+#
+#
+# For example, given numRows = 5,
+# Return
+#
+# [
+#      [1],
+#     [1,1],
+#    [1,2,1],
+#   [1,3,3,1],
+#  [1,4,6,4,1]
+# ]
+#
+#
+
+
+class Solution(object):
+    def generate(self, numRows):
+        """
+        :type numRows: int
+        :rtype: List[List[int]]
+        """
+        if numRows == 0:
+            return []
+        
+        if numRows == 1:
+            return [[1]]
+        
+        tmp = self.generate(numRows-1)            
+        # x = [0] + tmp[-1]
+        # y = tmp[-1] + [0]
+        # a = [x[i]+y[i] for i,_ in enumerate(x)]
+        a = list(map(lambda x, y: x+y, tmp[-1] + [0], [0] + tmp[-1]))
+        return tmp + [a]