更新部分

Author: OnlyChristmas

Python/array-partition-i.py

@@ -18,9 +18,23 @@ def arrayPairSum(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        # 思路一: 本问题相当于从小大到排序后，所有偶数之和
+        # Approach one
+        # ans = 0
+        # new_nums = sorted(nums)
+        # for i in range(0,len(new_nums),2):
+        #     ans += new_nums[i]
+        # return ans
+
+        # Approach two  进一步简化代码，无需新数组
+        # ans = 0
+        # nums.sort()
+        # for i in nums[::2]:
+        #     ans += i
+        # return ans
+
+        # Approach three: 本问题相当于从小大到排序后，所有偶数之和
         # return sum([num for i, num in enumerate(sorted(nums)) if i % 2 == 0])
 
-        # 思路二: 利用数组切片，进一步简化操作
+        # Approach Four: 利用数组切片，进一步简化操作
         # python 内置的sorted() 的平均/最坏时间复杂度均为 $O(nlog_2(n))$, 可以说是非常威武了。
         return sum(sorted(nums)[::2])

Python/best-time-to-buy-and-sell-stock-ii.py

@@ -0,0 +1,43 @@
+'''
+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 (i.e., buy one and sell one share of the stock multiple times).
+
+Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).
+
+Example 1:
+
+Input: [7,1,5,3,6,4]
+Output: 7
+Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+             Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+Example 2:
+
+Input: [1,2,3,4,5]
+Output: 4
+Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
+             engaging multiple transactions at the same time. You must sell before buying again.
+Example 3:
+
+Input: [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transaction is done, i.e. max profit = 0.
+
+'''
+
+
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+
+        # 从问题的本质入手，而不是观察示例序列的规律。
+        # 优化目标是总的赚钱利润，用贪心算法，只要是相隔两天有盈利就操作，即可得到最大利润（现实环境没有这么“干净”的问题）
+        maxPro = 0
+        for i in range(1,len(prices)):
+            if prices[i] > prices[i-1]:
+                maxPro += prices[i] - prices[i-1]
+        return maxPro

Python/binary-tree-longest-consecutive-sequence.py

@@ -0,0 +1,47 @@
+'''
+Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn't one, return 0 instead.
+
+Example:
+
+Input: s = 7, nums = [2,3,1,2,4,3]
+Output: 2
+Explanation: the subarray [4,3] has the minimal length under the problem constraint.
+Follow up:
+If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).
+
+
+'''
+
+
+class Solution:
+    def minSubArrayLen(self, s, nums):
+        """
+        :type s: int
+        :type nums: List[int]
+        :rtype: int
+        """
+        # Approach one
+        # left = 0
+        # ans = 10000000
+        # for i in range(len(nums)):
+        #     while sum(nums[left:i+1]) >= s:
+        #         ans = min(ans, i - left + 1)
+        #         left += 1
+        # return ans if ans != 10000000 else 0   # 处理没有答案的特殊情况
+
+
+        # Approach two
+        left,tmp,ans = 0,0,10000000
+        for i in range(len(nums)):
+            tmp += nums[i]
+            while tmp >= s:                # 减少重复的求和操作
+                if ans > i - left +1:
+                    ans = i - left +1      # min()、max() 函数耗费时间过多
+                tmp -= nums[left]
+                left += 1
+        return ans if ans != 10000000 else 0   # 处理没有答案的特殊情况
+
+
+
+
+            

Python/delete-node-in-a-linked-list.py

@@ -0,0 +1,41 @@
+'''
+Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
+
+Given linked list -- head = [4,5,1,9], which looks like following:
+
+
+
+Example 1:
+
+Input: head = [4,5,1,9], node = 5
+Output: [4,1,9]
+Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
+Example 2:
+
+Input: head = [4,5,1,9], node = 1
+Output: [4,5,9]
+Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
+Note:
+
+The linked list will have at least two elements.
+All of the nodes' values will be unique.
+The given node will not be the tail and it will always be a valid node of the linked list.
+Do not return anything from your function.
+'''
+
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def deleteNode(self, node):
+        """
+        :type node: ListNode
+        :rtype: void Do not return anything, modify node in-place instead.
+        """
+
+        node.val = node.next.val
+        node.next = node.next.next

Python/diagonal-traverse.py

@@ -0,0 +1,90 @@
+'''
+Given a matrix of M x N elements (M rows, N columns), return all elements of the matrix in diagonal order as shown in the below image.
+
+
+
+Example:
+
+Input:
+[
+ [ 1, 2, 3 ],
+ [ 4, 5, 6 ],
+ [ 7, 8, 9 ]
+]
+
+Output:  [1,2,4,7,5,3,6,8,9]
+
+Explanation:
+
+
+
+Note:
+
+The total number of elements of the given matrix will not exceed 10,000.
+
+'''
+
+
+class Solution:
+    def findDiagonalOrder(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: List[int]
+        """
+        # Approach one   效率低
+        # if matrix == []: return []
+        # ans = []
+        # row,col = len(matrix), len(matrix[0])
+        # if row == 1: return matrix[0]
+        # for num in range(row + col):
+        #     if num % 2 == 0:
+        #         for i in range(num+1):
+        #             if i >= col:
+        #                 break
+        #             if num - i >= row:
+        #                 continue
+        #             ans.append(matrix[num - i][i])
+        #     else:
+        #         for i in range(num+1):
+        #             if i >= row:
+        #                 break
+        #             if num - i >= col:
+        #                 continue
+        #             ans.append(matrix[i][num - i])
+        # return ans
+
+
+        # Approach two   不是用循环，免去遍历多余的数, 时间效率前100%
+        if matrix == []: return []
+        row,col = len(matrix), len(matrix[0])
+        ans = []
+        number = row * col
+        i = j = 0
+        up = True
+        while number:
+            number -= 1
+            ans.append(matrix[i][j])
+            if up:
+                if j == col - 1:
+                    i += 1
+                    up = False
+                elif i == 0:
+                    j += 1
+                    up = False
+                else:
+                    i -= 1
+                    j += 1
+            else:
+                if i == row - 1:
+                    up = True
+                    j += 1
+                elif j == 0:
+                    i += 1
+                    up = True
+                else:
+                    i += 1
+                    j -= 1
+        return ans
+
+
+        

Python/find-pivot-index.py

@@ -0,0 +1,59 @@
+'''
+Given an array of integers nums, write a method that returns the "pivot" index of this array.
+
+We define the pivot index as the index where the sum of the numbers to the left of the index is equal to the sum of the numbers to the right of the index.
+
+If no such index exists, we should return -1. If there are multiple pivot indexes, you should return the left-most pivot index.
+
+Example 1:
+Input:
+nums = [1, 7, 3, 6, 5, 6]
+Output: 3
+Explanation:
+The sum of the numbers to the left of index 3 (nums[3] = 6) is equal to the sum of numbers to the right of index 3.
+Also, 3 is the first index where this occurs.
+Example 2:
+Input:
+nums = [1, 2, 3]
+Output: -1
+Explanation:
+There is no index that satisfies the conditions in the problem statement.
+Note:
+
+The length of nums will be in the range [0, 10000].
+Each element nums[i] will be an integer in the range [-1000, 1000].
+
+'''
+
+
+class Solution:
+    def pivotIndex(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+
+        # Approach one 低效的方法
+        # for i in range(len(nums)):
+        #     if sum(nums[:i]) == sum(nums[i+1:]):
+        #         return i
+        # return -1
+
+        # Approach two
+        # 注意，中心索引可以为第一个元素，左侧没有元素，其和默认为0
+        # leftsum = 0
+        # rightsum = sum(nums)
+        # for i in range(len(nums)):
+        #     if i >= 1: leftsum += nums[i-1]
+        #     rightsum -= nums[i]
+        #     if leftsum == rightsum: return i
+        # return -1
+
+
+        # Approach three  将中心索引分别算进左右的元素之和，减少判断语句的使用
+        leftsum, rightsum = 0, sum(nums)
+        for i in range(len(nums)):
+            leftsum += nums[i]
+            if leftsum == rightsum: return i
+            rightsum -= nums[i]
+        return -1

Python/implement-strstr.py

@@ -65,7 +65,3 @@ def strStr(self, haystack, needle):
             if haystack[i:i+len(needle)]==needle:       #　字符串切片操作可以直接比较一个子串，不用每个字符都比较
                 return i                              # i 为 0 的时候， haystack[0:0] 表示为 0
         return -1
-
-
-
-

Python/largest-number-at-least-twice-of-others.py

@@ -32,15 +32,43 @@ def dominantIndex(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        # Approach #1
+        # Approach one   重复遍历,效率偏低
+        # max_num = max_id = 0
+        # for i,num in enumerate(nums):
+        #     if num > max_num:
+        #         max_num = num
+        #         max_id = i
+        # nums.remove(max_num)
+        # if nums != [] and max_num < max(nums)*2: return -1    # 防止列表只有一个元素
+        # return max_id
+
+
+        # Approach two  简化代码，但仍重复遍历
+        # if len(nums) == 1 : return 0
+        # max_num = max(nums)
+        # max_id = nums.index(max_num)
+        # nums.remove(max_num)
+        # if max_num >= max(nums) * 2: return max_id
+        # return -1
+
+
+        # Approach three
         # max_num = max(nums)
         # for num in nums:
         #     if 2*num > max_num and num != max_num:
         #         return -1
         # return nums.index(max_num)
 
-        # Approach #2
-        max_num = max(nums)
-        max_loc = nums.index(max_num)
-        nums[max_loc] = 0
-        return max_loc if max_num >= max(nums) *2 else -1 
+        # Approach four
+        # max_num = max(nums)
+        # max_loc = nums.index(max_num)
+        # nums[max_loc] = 0               # 通过置零，而不是删除，解决只有一个元素的情况。
+        # return max_loc if max_num >= max(nums) *2 else -1
+
+        # Approach five  只需一次排序，效率最高
+        if len(nums) > 1:
+            max_nums = sorted(nums)
+            if max_nums[-1] >= max_nums[-2] * 2:
+                return nums.index(max_nums[-1])
+            return -1
+        return 0    # 只有一个元素时需要特殊处理