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

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

    你可以假设除了数字 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. package main
    3. import "fmt"
    5. type ListNode struct {
    6.     Val  int
    7.     Next *ListNode
    8. }
    10. func main() {
    11.     fmt.Println("2. 两数相加")
    12.     l11 := &ListNode{Val: 3, Next: nil}
    13.     l12 := &ListNode{Val: 4, Next: l11}
    14.     l13 := &ListNode{Val: 2, Next: l12}
    15.     l14 := &ListNode{Val: 9, Next: l13}
    16.     printList(l14)
    18.     l21 := &ListNode{Val: 4, Next: nil}
    19.     l22 := &ListNode{Val: 6, Next: l21}
    20.     l23 := &ListNode{Val: 5, Next: l22}
    21.     printList(l23)
    22.     res := addTwoNumbers(l14, l23)
    23.     printList(res)
    24. }
    26. func printList(node *ListNode) {
    27.     for node != nil {
    28.         fmt.Print(" ", node.Val)
    29.         node = node.Next
    30.     }
    31.     fmt.Println()
    32. }
    34. /**
    35.  * Definition for singly-linked list.
    36.  * type ListNode struct {
    37.  *     Val int
    38.  *     Next *ListNode
    39.  * }
    40.  */
    41. func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    43.     carry := 0
    44.     temp := &ListNode{}
    45.     head := temp
    46.     for l1 != nil && l2 != nil {
    47.         sum := l1.Val + l2.Val + carry
    48.         node := &ListNode{}
    49.         node.Val = sum % 10
    50.         carry = sum / 10
    51.         temp.Next = node
    52.         temp = node
    53.         l1 = l1.Next
    54.         l2 = l2.Next
    55.     }
    56.     for l1 != nil {
    57.         sum := l1.Val + carry
    58.         node := &ListNode{}
    59.         node.Val = sum % 10
    60.         carry = sum / 10
    61.         temp.Next = node
    62.         temp = node
    63.         l1 = l1.Next
    64.     }
    65.     for l2 != nil {
    66.         sum := l2.Val + carry
    67.         node := &ListNode{}
    68.         node.Val = sum % 10
    69.         carry = sum / 10
    70.         temp.Next = node
    71.         temp = node
    72.         l2 = l2.Next
    73.     }
    74.     if carry > 0 {
    75.         node := &ListNode{}
    76.         node.Val = carry
    77.         temp.Next = node
    78.         temp = node
    79.     }
    80.     return head.Next
    81. }

    https://leetcode-cn.com/submissions/detail/193173502/