给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

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

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

public class ListNode {
    public var val: Int
    public var next: ListNode?
    public init(_ val: Int) {
        self.val = val
        self.next = nil
    }
    
    func log() -> Void {
        print("\(self.val)")
    }
}

func getNode(_ nums: [Int]) -> ListNode? {
    var firstNode: ListNode?
    var beforeNode: ListNode?
    for num in nums {
        let node = ListNode(num)
        if beforeNode != nil {
            beforeNode?.next = node
        }else {
            firstNode = node
        }
        beforeNode = node
    }
    return firstNode
}
 
func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
    var node1 = l1
    var node2 = l2
    
    let node = ListNode(-1)
    var currentNode = node
    //是否大于10的标记
    var carry = 0
    while node1 != nil || node2 != nil {
        let n1 = (node1 == nil) ? 0 : (node1?.val ?? 0)
        let n2 = (node2 == nil) ? 0 : (node2?.val ?? 0)
        let sum = n1 + n2 + carry
        carry = (sum >= 10) ? 1 : 0
        currentNode.next = ListNode(sum % 10)
        currentNode = currentNode.next!
        if node1 != nil {
            node1 = node1?.next
        }
        if node2 != nil {
            node2 = node2?.next
        }
    }
    //如果最后一位计算完成后 carry == 1 (计算结果大于10) 则再添加一个节点
    if carry == 1 {
        currentNode.next = ListNode(1)
    }
    return node.next
}

func showLog(_ node: ListNode?) -> Void {
    if node != nil {
        node?.log()
        if node?.next != nil {
            showLog(node?.next)
        }
    }
}

let node1 = getNode([2, 4, 3])
let node2 = getNode([5, 6, 4])
let node = addTwoNumbers(node1, node2)
showLog(node)