hot 100 刷题记录（1）

两数之和

思路：建一个哈希表（dict），遍历数组，如果target-nums[i]的值在哈希表里面，返回；否则，存储

python 复制代码

def sum2target(nums, target):
    d = dict()
    for i, num in enumerate(nums):
        if (target - num) in d:
            return [d[target - num], i]
        d[num] = i

2.两数相加

题目：

给定两个非空的链表，表示两个非负整数。

它们每位数字都是按照逆序方式存储的，并且每个节点只能存储一位数字。

请你将这两个数相加，并以相同形式返回一个表示和的链表。

思路：

新建一个链表，遍历两个链表，用temp记录进位

python 复制代码

class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next = next

    def add2list(self,headA,headB):
        dummy = ListNode()
        cur = dummy
        temp = 0
        p1 = headA
        p2 = headB
        while p1 or p2 or temp:
            val1 = p1.val if p1 else 0
            val2 = p2.val if p2 else 0
            cur.next = ListNode((val1+val2+temp)%10)
            temp = (val1+val2)//10
            cur = cur.next
            if p1: p1 = p1.next
            if p2: p2 = p2.next
        return dummy.next
    def printList(self,list):
        while list:
            print(list.val, end=" ")
            list = list.next
        print()
headA = ListNode(2)
headA.next = ListNode(4)
headA.next.next = ListNode(3)
headB = ListNode(5)
headB.next = ListNode(6)
headB.next.next = ListNode(4)
s = ListNode()
s.add2list(headA, headB)
s.printList(s.add2list(headA, headB))

无重复字符的最长子串

题目：给定一个字符串 s，请你找出其中无重复字符的最长子串 的长度。

也就是说，要求子串中的每个字符都不重复，返回这样的最长子串的长度。

思路：滑动窗口

用left和right维护窗口的左右边界。
d[ch]记录字符ch最近一次出现的位置。
每次都更新maxlen
核心：

如果新的ch已经在d里面了，并且位置在left右侧，证明当前窗口里面有这个字符，需要移动left到这个字符之后，保证当前窗口无重复字符

python 复制代码

def maxSubStr(s):
    d = dict()
    left = 0
    maxlen = 0
    for right,ch in enumerate(s):
        if ch in d and d[ch]>=left:
            left = d[ch] + 1
        d[ch] = right
        maxlen = max(maxlen, right - left + 1)
    return maxlen

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2，请你找出并返回这两个正序数组的中位数。

思路：二分查找，找中间元素

python 复制代码

def middleNumArrays(nums1, nums2):
    m, n = len(nums1), len(nums2)
    if m > n:
        nums1, nums2, m, n = nums2, nums1, n, m  # 保证nums1更短
    left, right = 0, m
    while left <= right:
        i = (left + right) // 2
        j = (m + n + 1) // 2 - i
        Aleft = nums1[i-1] if i > 0 else float('-inf')
        Aright = nums1[i] if i < m else float('inf')
        Bleft = nums2[j-1] if j > 0 else float('-inf')
        Bright = nums2[j] if j < n else float('inf')
        
        if Aleft <= Bright and Bleft <= Aright:
            if (m + n) % 2 == 0:
                return (max(Aleft, Bleft) + min(Aright, Bright)) / 2
            else:
                return max(Aleft, Bleft)
        elif Aleft > Bright:
            right = i - 1
        else:
            left = i + 1

给定一个字符串 s，找到 s 中最长的回文子串，并返回该子串。

思路：中心扩展法，分奇偶长度，从中间开始遍历，返回最大的左右位置

python 复制代码

def expandHuiWen(s, left, right):
    while left >= 0 and right < len(s) and s[left] == s[right]:
        left -= 1
        right += 1
    return left + 1, right - 1  # 返回回文的左右边界

def longestHuiWen(s):
    start, end = 0, 0
    for i in range(len(s)):
        l1, r1 = expandHuiWen(s, i, i)     # 奇数长度
        l2, r2 = expandHuiWen(s, i, i+1)   # 偶数长度
        if r1 - l1 > end - start:
            start, end = l1, r1
        if r2 - l2 > end - start:
            start, end = l2, r2
    return s[start:end+1]