2019.3.16

Author: OnlyChristmas

Python/intersection-of-two-linked-lists.py

@@ -0,0 +1,67 @@
+'''
+
+Write a program to find the node at which the intersection of two singly linked lists begins.
+
+For example, the following two linked lists:
+
+
+begin to intersect at node c1.
+
+
+
+Example 1:
+
+
+Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
+Output: Reference of the node with value = 8
+Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.
+
+
+Example 2:
+
+
+Input: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+Output: Reference of the node with value = 2
+Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [0,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.
+
+
+Example 3:
+
+
+Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+Output: null
+Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
+Explanation: The two lists do not intersect, so return null.
+
+
+Notes:
+
+If the two linked lists have no intersection at all, return null.
+The linked lists must retain their original structure after the function returns.
+You may assume there are no cycles anywhere in the entire linked structure.
+Your code should preferably run in O(n) time and use only O(1) memory.
+
+'''
+
+
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def getIntersectionNode(self, headA, headB):
+        """
+        :type head1, head1: ListNode
+        :rtype: ListNode
+        """
+
+        # Approach one  循环两次，消除相交点之前的长度差
+        if not headA or not headB : return None
+        p1, p2 = headA, headB
+        while(p1 != p2):
+            p1 = headB if not p1 else p1.next
+            p2 = headA if not p2 else p2.next
+        return p1

Python/lowest-common-ancestor-of-a-binary-search-tree.py

@@ -0,0 +1,57 @@
+'''
+
+Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.
+
+According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”
+
+Given binary search tree:  root = [6,2,8,0,4,7,9,null,null,3,5]
+
+
+
+
+Example 1:
+
+Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
+Output: 6
+Explanation: The LCA of nodes 2 and 8 is 6.
+Example 2:
+
+Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
+Output: 2
+Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+
+
+Note:
+
+All of the nodes' values will be unique.
+p and q are different and both values will exist in the BST.
+
+'''
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+
+        # # Approach one   递归求解
+        # if p.val < root.val > q.val:
+        #     return self.lowestCommonAncestor(root.left, p, q)
+        # if p.val > root.val < q.val:
+        #     return self.lowestCommonAncestor(root.right, p, q)
+        # return root
+
+
+        # Approach two   迭代求解
+        while True:
+            if p.val < root.val > q.val:
+                root = root.left
+            elif p.val > root.val < q.val:
+                root = root.right
+            else:
+                return root

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

@@ -33,10 +33,5 @@ def maxDepth(self, root):
         :type root: TreeNode
         :rtype: int
         """
-        # root 结点为空的时候，单独处理
-        if root is None:
-            return 0
-
-        # 注意，加一操作放在外边可以减少加法运算，不影响比大小的结果。
+        if not root : return 0
         return max(self.maxDepth(root.left), self.maxDepth(root.right))+1
-

Python/maximum-subarray.py

@@ -0,0 +1,39 @@
+'''
+Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
+
+Example:
+
+Input: [-2,1,-3,4,-1,2,1,-5,4],
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+Follow up:
+
+If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.
+
+
+
+'''
+
+
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+
+        # Approach one  暴力滑窗 TLE
+        # res = [nums[0]]
+        # for i in range(len(nums)):
+        #     for j in range(i+1, len(nums)+1):
+        #         res.append(sum(nums[i:j]))
+        # return max(res)
+
+
+        # Approach two  DP
+        res = nums[0]
+        num = 0
+        for i in range(len(nums)):
+            num += nums[i]
+            if num > res:
+                res = num
+            if num < 0:
+                num = 0
+        return res

Python/spiral-matrix-ii.py

@@ -0,0 +1,62 @@
+'''
+Given a positive integer n, generate a square matrix filled with elements from 1 to n2 in spiral order.
+
+Example:
+
+Input: 3
+Output:
+[
+ [ 1, 2, 3 ],
+ [ 8, 9, 4 ],
+ [ 7, 6, 5 ]
+]
+
+
+'''
+
+
+class Solution(object):
+    def generateMatrix(self, n):
+        """
+        :type n: int
+        :rtype: List[List[int]]
+        """
+
+        # Approach one
+        res = [[ 0  for _ in range(n)] for _ in range(n)]    # 注意， 不可用 n *[n *[0]] 初始化
+        right , down , up ,left = True, False, False, False
+        i , j = 0 , 0
+        for num in range(1 , n*n+1):
+            if right:
+                res[i][j] = num
+                j += 1
+                if j == n or res[i][j] != 0:
+                    right, down = False, True
+                    j -= 1
+                    i += 1
+                    continue
+            if down:
+                res[i][j] = num
+                i += 1
+                if i == n or res[i][j] != 0:
+                    down, left = False, True
+                    i -= 1
+                    j -= 1
+                    continue
+            if left:
+                res[i][j] = num
+                j -= 1
+                if j == -1 or res[i][j] != 0:
+                    left, up = False, True
+                    j += 1
+                    i -= 1
+                    continue
+            if up:
+                res[i][j] = num
+                i -= 1
+                if i == -1 or res[i][j] != 0:
+                    up, right = False, True
+                    i += 1
+                    j += 1
+                    continue
+        return res

Python/subsets.py

@@ -0,0 +1,44 @@
+'''
+
+Given a set of distinct integers, nums, return all possible subsets (the power set).
+
+Note: The solution set must not contain duplicate subsets.
+
+Example:
+
+Input: nums = [1,2,3]
+Output:
+[
+  [3],
+  [1],
+  [2],
+  [1,2,3],
+  [1,3],
+  [2,3],
+  [1,2],
+  []
+]
+
+
+
+'''
+
+
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+
+        # Approach one  将nums拆解，递归求解， 相当于每次将nums[0] 添加到其他所有的已有子集中。
+        # if not nums: return [[]]
+        # res = self.subsets(nums[1:])
+        # return res + [[nums[0]] + s for s in res]
+
+
+        # Approach two 迭代求解, 消耗栈空间少
+        # res = [[]]
+        # for i in nums:
+        #     res += [ n + [i] for n in res]
+        # return res
+
+
+        # Approach three  华丽但不好想到的位运算处理法， 效率较低
+        return [[nums[j] for j in range(len(nums)) if i>>j&1] for i in range(2**len(nums))]

Python/symmetric-tree.py

@@ -0,0 +1,62 @@
+'''
+
+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:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+
+      # Approach one  递归法
+#     def isSymmetric(self, root: TreeNode) -> bool:
+#         if not root : return True
+#         return self.judge_tree(root.left , root.right)
+
+
+#     def judge_tree(self, left , right):
+#         if not left and not right : return True
+#         if left and right :
+#             if left.val == right.val :
+#                 return self.judge_tree(left.left, right.right) and self.judge_tree(left.right , right.left)
+#         return False
+
+
+    #  Approach two 迭代
+    def isSymmetric(self, root: TreeNode) -> bool:
+        if not root : return True
+        qlist=[root.left, root.right]
+        while len(qlist)!=0:
+            t1=qlist.pop()
+            t2=qlist.pop()
+            if not t1 and not t2: continue
+            if not t1 or not t2: return False
+            if t1.val != t2.val : return False
+            qlist.append(t1.left)
+            qlist.append(t2.right)
+            qlist.append(t1.right)
+            qlist.append(t2.left)
+        return True