两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

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

你可以假设除了数字 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]
输入：l1 = [0], l2 = [0]
输出：[0]

提示：

• 每个链表中的节点数在范围 [1, 100] 内
• 0 <= Node.val <= 9
• 题目数据保证列表表示的数字不含前导零

方法一：模拟
思路与算法

由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。

我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2进位值为carry，则它们的和为 n1+n2+carry；其中，答案链表处相应位置的数字为=(n1+n2+carry)mod10，而新的进位值为⌊n1+n2+carry⌋/ 10 。

如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 00 。

此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为carry。

#
# @lc app=leetcode.cn id=2 lang=python3
#
# [2] 两数相加
#

# @lc code=start
# 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:
        # 当前指针，结果链表
        result = curr = ListNode()
        # 进位项
        remainder = 0

        # 非空满足循环条件
        while l1 or l2 :
            x = l1.val if l1 else 0
            y = l2.val if l2 else 0

            total = x + y + remainder

            curr.next = ListNode(total%10)
            remainder = total//10
# 防止某一链表已经为空，空链表.next会报错
            if l1 : 
                l1 = l1.next
            if l2 : 
                l2 = l2.next
            curr = curr.next

        if remainder : 
            curr.next = ListNode(remainder)
        return result.next

        
# @lc code=end

  给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

输入：nums = [3,2,4], target = 6
输出：[1,2]

解题思路
1 暴力解法：每个元素都被枚举多次，算法时间复杂度为o(n^2)

2用 Python 中 list 的相关函数求解

解题关键主要是想找到 num2 = target – num1，是否也在 list 中，那么就需要运用以下两个方法：

num2 in nums，返回 True 说明有戏
nums.index(num2)，查找 num2 的索引

def twoSum(nums, target):
    lens = len(nums)
    j=-1
    for i in range(lens):
        if (target - nums[i]) in nums:
            if (nums.count(target - nums[i]) == 1)&(target - nums[i] == nums[i]):#如果num2=num1,且nums中只出现了一次，说明找到是num1本身。
                continue
            else:
                j = nums.index(target - nums[i],i+1) #index(x,i+1)是从num1后的序列后找num2                
                break
    if j>0:
        return [i,j]
    else:
        return []

哈希表：类似字典，key:value
哈希解法：只要一次遍历，遍历到i时，在哈希表中查找target-i是否存在即可
若target-i存在：返回i和target-i的下标
若target-i不在：在哈希表中添加第i个元素
时间：o(n)
空间：o(n)

解题思路：哈希表

如果我们使用暴破，会导致时间复杂度为 n^2这样的代价无疑是很大的。 所以我们很容易想到用哈希表来解决这个问题。
我们遍历到数字 a 时，用 target 减去 a，就会得到 b，若 b 存在于哈希表中，我们就可以直接返回结果了。若 b 不存在，那么我们需要将 a 存入哈希表，好让后续遍历的数字使用。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable=dict()
        for i,num in enumerate(nums):
            if target-num in hashtable:
                return [hashtable[target-num],i]
            hashtable[num]=i
# @lc code=end

补充知识：

​Python 3 新特性：类型注解

前几天有同学问到，这个写法是什么意思：

def add(x:int, y:int) -> int:
    return x + y

我们知道 Python 是一种动态语言，变量以及函数的参数是不区分类型。因此我们定义函数只需要这样写就可以了：

def add(x, y):
    return x + y

这样的好处是有极大的灵活性，但坏处就是对于别人代码，无法一眼判断出参数的类型，IDE 也无法给出正确的提示。

于是 Python 3 提供了一个新的特性：
函数注解

也就是文章开头的这个例子：

def add(x:int, y:int) -> int:
    return x + y

用 : 类型 的形式指定函数的参数类型，用 -> 类型 的形式指定函数的返回值类型

在 Python 3.6 中，又引入了对变量类型进行注解的方法：

a: int = 123
b: str = 'hello'

更进一步，如果你需要指明一个全部由整数组成的列表：

from typing import List
l: List[int] = [1, 2, 3]

但同样，这些仅仅是“注解”，不会对代码产生任何影响。