2. 两数相加

题目描述：

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

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

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

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

思路:

这题已经简化很多了，但是还是要考虑挺多情况，最重要的就是进位情况，弄一个新的链表用来存放两个链表的值，如果两个链表不等长，就把长的那个直接放在l3后面，最重要的这个时候要考虑连续进位的情况，记得用循环解决

代码:

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1.Next==nil&&l1.Val==0{
        return l2
    }else if l2.Next==nil&&l2.Val==0{
        return l1
    }
    var flag int
    l3 := &ListNode{}
    head :=l3
    l3 .Val =l1.Val+l2.Val
    if l3.Val>=10{
        l3.Val %=10
        flag=1
    }
    l1 = l1.Next
    l2 = l2.Next 
    for l1!=nil&&l2 !=nil{
        node := &ListNode{}
        l3.Next=node
        l3 = node
        l3. Val  +=(l1.Val+l2.Val+flag)
        if l3.Val>=10{
            l3.Val %= 10
            flag =1
        }else{
            flag = 0
        }
        l1 = l1.Next
        l2 = l2.Next
    }
    //l2和l1等长
    if l2==nil && l1 ==nil {
        if flag == 1 {
            node := &ListNode{Val: 1}
            l3.Next = node
        }
        //l2长
    }else if l1==nil{
        l3.Next = l2
        if flag==1{
            l2.Val++
            for l2.Val>=10{
                if l2.Next==nil{ //连续进位情况
                    node := &ListNode{Val: 1}
                    l2.Val = 0 
                    l2.Next = node
                    break
                }
                l2.Val %=10
                l2=l2.Next
                l2.Val++
            }
        }
        //l1长
    }else  if l2==nil{
        l3.Next = l1
        if flag ==1{
            l1.Val++
            for l1.Val>=10{
                if l1.Next == nil{
                    node := &ListNode{Val: 1}//连续进位情况
                    l1.Val=0
                    l1.Next= node          
                    break
                }
                l1.Val %=10
                l1=l1.Next
                
                l1.Val++
            }
        }
    }
    return head
}

代码效率：

执行用时：12 ms, 在所有 Go 提交中击败了72.47%的用户
内存消耗：4.6 MB, 在所有 Go 提交中击败了97.34%的用户