note

Author: 425776024

easyleetcode/leetcodes/Leetcode_002_Add_Two_Numbers.py

@@ -0,0 +1,74 @@
+
+
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+def make_list(arr: list):
+    head_node = None
+    p_node = None
+    for a in arr:
+        new_node = ListNode(a)
+        if head_node is None:
+            head_node = new_node
+            p_node = new_node
+        else:
+            p_node.next = new_node
+            p_node = new_node
+    return head_node
+
+
+def print_list(head: ListNode):
+    while head is not None:
+        print(head.val, end=',')
+        head = head.next
+
+
+class Solution:
+    def two_list_sum(self, head1: ListNode, head2: ListNode):
+        p = 0
+        sumlist = ListNode(0)
+        pre = sumlist
+        # 长度可能不一样，只要有一个有值，就得继续
+        while head1 is not None or head2 is not None:
+            # 分3种情况讨论
+            if head1 is not None and head2 is not None:
+                v = head1.val + head2.val + p
+                head1 = head1.next
+                head2 = head2.next
+            elif head1 is not None and head2 is None:
+                v = head1.val + p
+                head1 = head1.next
+            else:
+                v = head2.val + p
+                head2 = head2.next
+            p = 0
+            if v > 9:
+                v = v - 10
+                p = 1
+            node = ListNode(v)
+            pre.next = node
+            pre = node
+        # 最为关键，如果前面一步还能进位，不要了？
+        if p == 1:
+            node = ListNode(1)
+            pre.next = node
+
+        return sumlist
+
+
+s = Solution()
+a = [3, 1, 5]
+a2 = [5, 9, 5, 9]
+head1 = make_list(a)
+head2 = make_list(a2)
+print_list(head1)
+print()
+print_list(head2)
+print()
+
+# res_sum.next ? 不需要头节点的伪值
+res_sum = s.two_list_sum(head1, head2).next
+print_list(res_sum)

easyleetcode/leetcodes/Leetcode_004_Median of two Sorted Arrays.py

@@ -0,0 +1,48 @@
+'''
+合并两个排序数组，然后取中位数
+'''
+
+
+def merge(A, B):
+    lena = len(A)
+    lenb = len(B)
+    lenc = lena + lenb
+    C = [0] * lenc
+    i, j = 0, 0
+    c = 0
+    while c < lenc and j < lenb and i < lena:
+        if A[i] > B[j]:
+            C[c] = B[j]
+            j += 1
+        else:
+            C[c] = A[i]
+            i += 1
+        c += 1
+    while j < lenb:
+        C[c] = B[j]
+        j += 1
+    while i < lena:
+        C[c] = A[i]
+        i += 1
+    return C
+
+
+def median(A):
+    if len(A) % 2 == 0:
+        mid1 = int(len(A) / 2) - 1
+        mid2 = int(len(A) / 2)
+        return (A[mid1] + A[mid2]) / 2
+    else:
+        mid = int(len(A) / 2)
+        return A[mid]
+
+
+'''
+先合并，然后判断单、双，去中位数
+'''
+
+A = [1, 2, 3, 4, 5, 6]
+B = [2, 3, 4, 5]
+C = merge(A, B)
+print(C)
+print(median(C))

easyleetcode/leetcodes/Leetcode_0153_Find Minimum in Rotated Sorted Array.py

@@ -0,0 +1,25 @@
+class Solution:
+    def search(self, A):
+        if A is None:
+            return -1
+        start = 0
+        end = len(A) - 1
+        mid = 0
+        while start + 1 < end:
+            mid = start + int((end - start) / 2)
+            # 在右边 片段
+            if A[mid] < A[end]:
+                end = mid
+            else:
+                # 在左边 片段
+                start = mid
+        if A[start] < A[end]:
+            return A[start]
+        else:
+            return A[end]
+
+
+# 从小到大的数组被旋转
+# 二分搜索，穷举旋转的时候，mid坐在左、右边情况
+s = Solution()
+print(s.search([3, 4, 4, 5, 7, 8, 1, 2]))

easyleetcode/leetcodes/Leetcode_033_Search in Rotated Sorted Array.py

@@ -0,0 +1,38 @@
+class Solution:
+    def search(self, A, target):
+        if A is None:
+            return -1
+        start = 0
+        end = len(A) - 1
+        mid = 0
+        while start + 1 < end:
+            # 取中点
+            mid = start + int((end - start) / 2)
+            # 如果找到直接返回
+            if target == A[mid]:
+                return mid
+            # 这一步很关键，可以区分mid在旋转后两段有序数组中的哪一段
+            if A[start] < A[mid]:
+                # 关键，显然此时target在mid左边，那么缩小区间为end = mid
+                if A[start] <= target and target < A[mid]:
+                    end = mid
+                else:  # 显然此时target在mid右，那么缩小区间为 start = mid
+                    start = mid
+            else:
+                # 关键
+                if A[mid] < target and target <= A[end]:
+                    start = mid
+                else:
+                    end = mid
+        # 此时就剩start、end两个点有可能了
+        if A[start] == target:
+            return start
+        if A[end] == target:
+            return end
+        return -1
+
+
+# 输入旋转排序数组
+# 搜索给定值的位置
+s = Solution()
+print(s.search([8, 9, 10, 11, 12, 13, 14, 4, 5, 6], 6))

easyleetcode/leetcodes/Leetcode_066_Plus_One.py

@@ -1,35 +1,18 @@
-class Solution(object):
-    # def plusOne(self, digits):
-    #     """
-    #     :type digits: List[int]
-    #     :rtype: List[int]
-    #     """
-    #     ls = len(digits)
-    #     curr, pos = 1, 0
-    #     while pos < ls:
-    #         index = ls - pos - 1
-    #         curr += digits[index]
-    #         digits[index] = curr % 10
-    #         curr /= 10
-    #         if curr == 0:
-    #             # do not need to continue
-    #             break
-    #         pos += 1
-    #     if curr > 0:
-    #         digits.insert(0, curr)
-    #     return digits
 
+class Solution:
     def plusOne(self, digits):
-        ls = len(digits)
-        for index in reversed(range(ls)):
-            if digits[index] < 9:
-                digits[index] += 1
-                # do not need to continue
+        n = len(digits)
+        for i in range(n - 1, -1, -1):
+            if digits[i] < 9:
+                digits[i] += 1
                 return digits
-            else:
-                # 10
-                digits[index] = 0
-        digits.insert(0, 1)
-        return digits
+            digits[i] = 0
 
+        res = [0] * (n + 1)
+        res[0] = 1
+        return res
 
+
+s = Solution()
+print(s.plusOne([9, 9, 9]))
+print(s.plusOne([1, 2, 9]))

easyleetcode/leetcodes/Leetcode_069_Sqrt(x).py

@@ -1,35 +1,24 @@
 class Solution:
-    # def mySqrt(self, x):
-    #     """
-    #     :type x: int
-    #     :rtype: int
-    #     """
-    #     if x == 0:
-    #         return 0
-    #     low = 0
-    #     high = x
-    #     last = x
-    #     while high >= low:
-    #         mid = (low + high) / 2
-    #         temp = mid * mid
-    #         if temp == x:
-    #             return mid
-    #         elif temp < x:
-    #             low = mid + 1
-    #             last = mid
-    #         else:
-    #             high = mid - 1
-    #     return last
-
+    # @param {integer} x
+    # @return {integer}
     def mySqrt(self, x):
-        # sqrt(x) = 2 * sqrt(x / 4) for n % 4 == 0
-        # sqrt(x) = 1 + 2 * sqrt(x / 4) for n % 4 != 0
-        if x == 0:
+        if x < 0:
+            return -1
+        elif x == 0:
             return 0
-        if x < 4:
-            return 1
-        res = 2 * self.mySqrt(x / 4)
-        # (res + 1) * (res + 1) >= 0 for avoiding overflow
-        if (res + 1) * (res + 1) <= x and (res + 1) * (res + 1) >= 0:
-            return res + 1
-        return  res
+
+        start, end = 1, x
+        while start + 1 < end:
+            mid = start + (end - start) / 2
+            if mid ** 2 == x:
+                return mid
+            # mid此时过大，那真实值在mid左边，所以end=mid逼近
+            elif mid ** 2 > x:
+                end = mid
+            else:  # mid此时小于目标，那么真实在右边，所以start逼近
+                start = mid
+        return start
+
+
+s = Solution()
+print(s.mySqrt(9))

easyleetcode/leetcodes/Leetcode_074_Search a 2D Matrix.py

@@ -0,0 +1,38 @@
+class Solution:
+    '''
+    一次二分搜索，把矩阵当数组看
+    '''
+
+    def search_matrix(self, matrix, target):
+        if not matrix or not matrix[0]:
+            return False
+        # 横，纵
+        m, n = len(matrix), len(matrix[0])
+        # 把矩阵当数组！
+        st, ed = 0, m * n - 1
+        while st + 1 < ed:
+            mid = int((st + ed) / 2)
+            # int(mid / n)取得1维索引，mid % n取得2维索引
+            v = matrix[int(mid / n)][mid % n]
+            if v == target:
+                return True, [int(mid / n), mid % n]
+            elif v < target:
+                st = mid
+            else:
+                ed = mid
+        if matrix[int(st / n)][st % n] == target:
+            return True, [int(st / n), st % n]
+        elif matrix[int(ed / n)][ed % n] == target:
+            return True, [int(ed / n), ed % n]
+        return False, [-1, -1]
+
+
+n = [
+    [1, 3, 5, 7],
+    [10, 11, 16, 20],
+    [23, 30, 34, 50]
+]
+
+s = Solution()
+print(s.search_matrix(n, 16))
+