leetcode 1-3 题解

题目描述

1.俩数和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target的
那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

这里提供俩种解法

# 暴力解
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in nums:
            j=target-i
            start_index=nums.index(i) # 第一加数的下标，
            next_index=start_index+1  # 丛第二个数开始
            temp_nums=nums[next_index:] # 切片 将取出的数排除
            if j in temp_nums:          # 如果找到满足条件的数则返回这一对数下标
                return (nums.index(i),next_index+temp_nums.index(j))


# 优化解 哈希表+字典
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dict={}
        for i in range(len(nums)):
            if target-nums[i] not in dict: # 这里表示检查的是key
                dict[nums[i]]=i   # 将数组值存入字典作为key,同时下标作为value
            else:
                return [dict[target-nums[i]],i] # dict[target-nums[i] 为value 即下标

2.链表求和
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，
并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头
个人解释：即将数字按  百十个 各位数字存储在链表
输入：l1 = [2,4,3], 
     l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
输入：l1 = [9,9,9,9,9,9,9], 
     l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 判空
        if l1==None:
            return l2
        if l2==None:
            return l1
        head=ListNode(0)
        p=head
        sum=0
        # 当l1 l2 都存在非空
        while l1 and l2:
            p.next=ListNode((l1.val+l2.val+sum)%10)
            sum=(l1.val+l2.val+sum)//10
            # 移到下一位
            l1=l1.next
            l2=l2.next
            p=p.next
        # l2 更长
        if l2:
            while l2:
                p.next = ListNode(( l2.val + sum) % 10)
                sum = (l2.val + sum) // 10
                # 移到下一位
                l2 = l2.next
                p = p.next
        # l1 更长
        if l1:
            while l1:
                p.next = ListNode(( l1.val + sum) % 10)
                sum = (l1.val + sum) // 10
                # 移到下一位
                l1 = l1.next
                p = p.next
        # l1 l2等长，最后一位相加后满10
        if sum==1:
            p.next=ListNode(1)
        return head.next

3.求最大子串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        dict={}
        start=-1
        max=0
        for i in range(len(s)):
            if s[i] in dict and dict[s[i]] >start:
                start=dict[s[i]]
                dict[s[i]]=i
            else:
                dict[s[i]]=i
                if i-start>max:
                    max=i-start
        return max

因为时间问题，就不一 一分析问题，代码中难以理解的地方，都加以注释，读者可根据注释进行理解，若还有不懂的地方，欢迎评论区留言，都会回复