记录一下python-leetcode（一）

一、Longest Substring Without Repeating Characters
描述：给定一个字符串，找到不含有重复字符的最长子串的长度
最简单的方法，双循环，从每个字符开始找到最长子串，然后输出最长的那个

def Longeststring(s):
    k = [] #存放不重复字符
    w = [] #存放长度
    longth = 0
    if len(s) == 0:
        return 0
    if len(s) == 1:
        return 1
    for j in range(len(s) - 1):
        for i in range(j, len(s)):
            if i == len(s) - 1 and s[i] not in k:
                longth += 1
                w.append(longth)
                return max(w)
            if s[i] not in k:
                longth += 1
                k.append(s[i])
            else:
                w.append(longth)
                longth = 0
                k.clear() #当找到重复字符的时候把k clear
    return max(w)

改进版：

def lengthOfLongestSubstring(self, s: str) -> int:
    dict = {} #存放不同字符串
    longth = 0 #不重复的长度长度
    start = 0 #开始的位置
    for index, item in enumerate(s):
        if item in dict:
            longth = max(longth, index - start) #如何找到了重复字符，更新长度
            start = max(start, dict[item] + 1) #更新开始的位置
        dict[item] = index #更新字典
    return max(longth, len(s) - start)

速度大概是暴力枚举的50分之一
二、Median of Two Sorted Arrays
描述：给定两个排好序的数组，找到两个数组的中位数,假定2个数组长度为n，m，时间复杂度应该为： O(log (m+n))
例如：a=[1,2] b=[3] 输出：2
a=[1, 2] b=[3,4] 输出：（2+3）/ 2 = 2.5
解决方法：

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        # 组合后的数组长度为偶数： ((mid) + (mid+1)) / 2
        # 长度为奇数输出 merged[len(merged)//2]
        # 比较困难的是排序时间复杂度为 O(n+m). 但是得达到O(log(n+m))
        def merge(A, B):
            i, j = 0, 0
            res = []
            while i < len(A) and j < len(B):
                if A[i] <= B[j]:
                    res.append(A[i])
                    i += 1
                else:
                    res.append(B[j])
                    j += 1
            if i < len(A): 
            	 res += A[i:] #如果B完事了，直接把A全部append
            if j < len(B):
            	 res += B[j:]
            return res
        merged = merge(nums1, nums2)
        mid = (len(merged) - 1) // 2
        if len(merged) % 2 == 0:
            return (merged[mid] + merged[mid + 1]) / 2
        else:
            return merged[mid]

我也试了一下直接用sorted直接重新排序A+B，答案也通过了，而且运行时间还更快，不得不说底层语言实现的归并排序还是更快点

def findMedianSortedArrays(self, nums1, nums2):
    x = sorted(nums1 + nums2)
    median = None
    n = len(x) // 2
    if len(x) % 2 == 1:
        median = x[n]
    else:
        median = (x[n] + x[n - 1]) / 2
    return median

三、Longest Palindromic Substring
描述：给定一个字符串，找到其中最长的对称子串，保证s的长度最大为1000
例如：“abcbbcca” 输出为：bbcc

def longestPalindrome(self, s):
    if len(s) < 2 or s == s[::-1]: #处理最简单的状况
        return s
    max_len = 1
    start = 0
    for i in range(1, len(s)):
        even = s[i - max_len: i + 1]
        odd = s[i - max_len - 1: i + 1]
        if i - max_len - 1 >= 0 and odd == odd[::-1]:
            start = i - max_len - 1 # 记录开始的位置
            max_len += 2  # 不看max_len 长度差2，所以+2
            continue  # 由于even跟odd长度只差了1，所以满足前者不可能满足后面的条件，所以直接continue
        if i - max_len >= 0 and even == even[::-1]:
            start = i - max_len
            max_len += 1 
    return s[start: start + max_len]

建议用调试模式一步一步看一个例子