LeetCode刷题——算法篇

 1

# 暴力解法
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        i = 0
        while i<len(nums):
            j = i+1
            while j<len(nums):
                if nums[i] + nums[j] == target:
                    return i,j
                j += 1
            i += 1
        return None

class Solution:
    # 哈希表实现
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dicts = {}
        for i, num in enumerate(nums):
            if num in dicts:
                return[dicts[num], i]
            else:
                dicts[target - num] = i
        return []

 2

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        carry  = 0
        res = pre = ListNode(0)
        while l1 or l2 or carry:
            if l1:
                carry += l1.val
                l1 = l1.next
            if l2:
                carry += l2.val
                l2 = l2.next
            carry, val = divmod(carry, 10)
            pre.next = pre = ListNode(val)
        return res.next

3

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        # 哈希表方法
        length = len(s)
        if length <= 0:
            return 0
        if length == 1:
            return 1
        
        head = 0
        max_length = 0
        myHashMap = {}
        for index in range(length):
            if s[index] in myHashMap and head <= myHashMap[s[index]]:
                head = myHashMap[s[index]] + 1
            else:
                max_length = max(max_length, index-head + 1)
            myHashMap[s[index]] = index
        return max_length

4

 

class Solution:
    # 暴力解法
    # 先合并，再排序
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        ans = nums1 + nums2
        ans.sort()
        n = len(ans)
        if n%2 == 0:
            return float((ans[n//2]+ans[(n//2)-1])/2)
        else:
            return float(ans[n//2])

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        #找到nums1和nums2固定范围内的第t小的数，left1、right1、left2、right2为nums1和nums2的范围。
        def find(left1,right1,left2,right2,t): 
            if left1 > right1: #此时其中一个数组已经无用，返回另一个数组的第t即可
                return nums2[left2+t-1]
            elif left2 > right2: #此时其中一个数组已经无用，返回另一个数组的第t即可
                return nums1[left1+t-1]
            if t == 1: #两数组都存在的递归结束条件，找最小的一个数
                return min(nums1[left1],nums2[left2])
            numm = t//2 #二分，向下取整，最多为t的一半
            #处理其中一个数组范围不足numm的情况，length表示判断之后丢弃的数的个数
            length1 = min(numm,right1-left1+1) 
            length2 = min(numm,right2-left2+1)
            #判断left+length-1的两个元素大小，调整两个数组的范围以及第几小元素，进行递归
            if nums1[left1+length1-1] <= nums2[left2+length2-1]:
                return find(left1+length1,right1,left2,right2,t-length1)
            else:
                return find(left1,right1,left2+length2,right2,t-length2)       
        m = len(nums1)
        n = len(nums2)
        #初始判断，处理其中有一个为空的情况
        if m == 0:
            if n%2 == 0:
                return float((nums2[n//2]+nums2[(n//2)-1])/2)
            else:
                return float(nums2[n//2])
        if n == 0:
            if m%2 == 0:
                return float((nums1[m//2]+nums1[(m//2)-1])/2)
            else:
                return float(nums1[m//2])
        ans = 0.0
        #分两种情况讨论返回
        if (m + n)%2 == 1:
            k = (m+n+1)//2
            ans = float(find(0,m-1,0,n-1,k))
        else:
            k = (m+n)//2
            ans = (float(find(0,m-1,0,n-1,k)) + float(find(0,m-1,0,n-1,k+1)))/2
        return ans

5

        最长回文子串或最长对称因子问题是在一个字符串中查找一个最长的连续的回文的子串，例如“banana”最长回文子串是“anana”。最长回文子串并不一定是唯一的，比如“abracadabra”，没有超过3的回文子串，但是有两个回文字串长度都是3：“ada”和“aca”。在一些应用中，我们求出全部的极大回文子串（不被其他回文串包含的回文子串）。

6

7

8

9

10

11

12

13

14

15

16

17