easy02

Author: princewen

easy/104_Maximum_Depth_of_Binary_Tree.py

@@ -0,0 +1,38 @@
+"""
+
+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.
+
+
+"""
+
+"""my solution 递归的方式"""
+
+# 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
+        else:
+            leftmax = self.maxDepth(root.left)+1
+            rightmax = self.maxDepth(root.right)+1
+            return max(leftmax,rightmax)
+
+"""other solution
+将我的思想转化为一行，巧妙利用了map函数
+"""
+
+def maxDepth(self, root):
+    return 1 + max(map(self.maxDepth, (root.left, root.right))) if root else 0
+

easy/107_Binary_Tree_Level_Order_Traversal_II.py

@@ -0,0 +1,66 @@
+"""
+
+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]
+]
+
+
+"""
+import collections
+"""solution1 : stack + dfs
+利用栈来进行存储深度优先搜索需要遍历的节点，注意压入栈的时候要先压入右节点，再压入左节点
+这样才能做到先访问左节点
+"""
+
+# 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 levelOrderBottom(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        stack = [(root,0)]
+        res = []
+        while stack!=[]:
+            node,level = stack.pop()
+            if node:
+                if len(res) < (level+1):
+                    res.insert(0,[])
+                res[-(level+1)].append(node.val)
+                stack.append((node.right,level+1))
+                stack.append((node.left,level+1))
+        return res
+
+"""solution2 利用队列
+
+"""
+
+def levelOrderBottom(self, root):
+    queue, res = collections.deque([(root, 0)]), []
+    while queue:
+        node, level = queue.popleft()
+        if node:
+            if len(res) < level+1:
+                res.insert(0, [])
+            res[-(level+1)].append(node.val)
+            queue.append((node.left, level+1))
+            queue.append((node.right, level+1))
+    return res

easy/108_Convert_Sorted Array to Binary Search Tree.py

@@ -0,0 +1,33 @@
+"""
+
+Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
+
+"""
+"""
+
+AVL tree 是一种特殊的二叉查找树，，首先我们要在树中引入平衡因子balance，
+表示结点右子树的高度减去左子树的高度差（右-左），对于一棵AVL树要么它是一棵空树，
+要么它是一棵高度平衡的二叉查找树，平衡因子balance绝对值不超过1
+
+"""
+# 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
+        else:
+            mid = len(nums)/2
+            root = TreeNode(nums[mid])
+            root.left = self.sortedArrayToBST(nums[:mid])
+            root.right = self.sortedArrayToBST(nums[mid+1:])
+            return root

easy/112_Path Sum.py

@@ -0,0 +1,41 @@
+"""
+
+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.
+
+"""
+
+
+"""my solution
+使用递归的思想，首先判断节点是否为空，然后判断是否到了叶子节点，如果不是叶子结点，继续往下走
+"""
+
+# 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
+        if root.left == None and root.right == None:
+            return root.val==sum
+        return self.hasPathSum(root.left,sum-root.val) or self.hasPathSum(root.right,sum-root.val)

easy/118_Pascal's Triangle.py

@@ -0,0 +1,55 @@
+"""
+
+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]
+]
+
+"""
+
+"""my solution
+暴力循环
+"""
+
+class Solution(object):
+    def generate(self, numRows):
+        """
+        :type numRows: int
+        :rtype: List[List[int]]
+        """
+        if numRows == 0:
+            return []
+        elif numRows == 1:
+            return [[1]]
+        elif numRows == 2:
+            return [[1],[1,1]]
+        else:
+            rows = [[1],[1,1]]
+            for i in range(3,numRows+1):
+                singlerow = []
+                for j in range(i):
+                    if j == 0 or j == i-1:
+                        singlerow.append(1)
+                    else:
+                        singlerow.append(rows[i-2][j-1]+rows[i-2][j])
+                rows.append(singlerow)
+            return rows
+
+"""other solution
+为什么append不行
+"""
+
+
+def generate(self, numRows):
+    res = [[1]]
+    for i in range(1, numRows):
+        res += [map(lambda x, y: x + y, res[-1] + [0], [0] + res[-1])]
+    return res[:numRows]

easy/119_Pascal's Triangle II.py

@@ -0,0 +1,41 @@
+"""
+
+Given an index k, return the kth row of the Pascal's triangle.
+
+For example, given k = 3,
+Return [1,3,3,1].
+
+Note:
+Could you optimize your algorithm to use only O(k) extra space?
+
+"""
+
+"""my solution
+这里要提醒一下map函数的应用，map在python2中返回的是一个list，而在python3中返回的是一个map object，必须加一个list来进行类型转换
+"""
+
+class Solution(object):
+    def getRow(self, rowIndex):
+        """
+        :type rowIndex: int
+        :rtype: List[int]
+        """
+        res = [1]
+        for i in range(1,rowIndex+1):
+            res = list(map(lambda x,y:x+y,res+[0],[0]+res))
+        return res
+
+"""other solution
+非常类似
+"""
+
+class Solution(object):
+    def getRow(self, rowIndex):
+        """
+        :type rowIndex: int
+        :rtype: List[int]
+        """
+        row = [1]
+        for _ in range(rowIndex):
+            row = [x + y for x, y in zip([0]+row, row+[0])]
+        return row

easy/121——Best Time to Buy and Sell Stock.py

@@ -0,0 +1,51 @@
+"""
+
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+
+Example 1:
+Input: [7, 1, 5, 3, 6, 4]
+Output: 5
+
+max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
+Example 2:
+Input: [7, 6, 4, 3, 1]
+Output: 0
+
+In this case, no transaction is done, i.e. max profit = 0.
+
+"""
+
+"""my solution
+直接超时
+"""
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        max = 0
+        for i in range(0,len(prices)-1):
+            for j in range(i+1,len(prices)):
+                if prices[j] - prices[i] > max:
+                    max = prices[j] - prices[i]
+        return max
+
+"""
+Kadane's Algorithm
+"""
+
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        maxCur = maxSoFar = 0
+        for i in range(1,len(prices)):
+            maxCur+=(prices[i]-prices[i-1])
+            maxCur = max(0,maxCur)
+            maxSoFar = max(maxCur,maxSoFar)
+        return maxSoFar

easy/122_Best Time to Buy and Sell Stock II.py

@@ -0,0 +1,15 @@
+"""
+
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+
+"""
+
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        return sum(max(prices[i+1]-prices[i],0) for i in range(len(prices)-1))

easy/125_Valid Palindrome.py

@@ -0,0 +1,39 @@
+"""
+
+Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+For example,
+"A man, a plan, a canal: Panama" is a palindrome.
+"race a car" is not a palindrome.
+
+Note:
+Have you consider that the string might be empty? This is a good question to ask during an interview.
+
+For the purpose of this problem, we define empty string as valid palindrome.
+
+"""
+"""
+两个指针，用isalnum判断是否是字母，注意统一转换成小写然后再比较
+"""
+
+class Solution(object):
+    def isPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        if not s:
+            return True
+        else:
+            i = 0
+            j = len(s) - 1
+            while i < j:
+                while i < j and not s[i].isalnum():
+                    i = i + 1
+                while i < j and not s[j].isalnum():
+                    j = j - 1
+                if s[i].lower() != s[j].lower():
+                    return False
+                i = i + 1
+                j = j - 1
+            return True