leetcode2

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

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

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

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

public class ListNode {
    public var val: Int
    public var next: ListNode?
    public init() { self.val = 0; self.next = nil; }
    public init(_ val: Int) { self.val = val; self.next = nil; }
    public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
}
//两数相加
//输入：l1 = [2,4,3], l2 = [5,6,4]
//输出：[7,0,8]
//解释：342 + 465 = 807.
class Solution {
    class func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        guard var node1 = l1, var node2 = l2 else{
            return nil   //两个链表不能为空
        }
        var sums = ListNode()
        var currentNode = sums
        var flags = (node1.val + node2.val)/10  //进位标记
        sums.val = (node1.val + node2.val)%10
        while node1.next != nil || node2.next != nil {
            let node = ListNode()
            let value = (node1.next?.val ?? 0) + (node2.next?.val ?? 0) + flags
            node.val = value % 10
            flags = value / 10
            currentNode.next = node
            currentNode = node
            if node1.next != nil {
                node1 = node1.next!
            }
            if node2.next != nil {
                node2 = node2.next!
            }
            print("循环了")
        }
        if flags > 0 {  //最后一个数进位处理
            let node = ListNode()
            node.val = flags
            currentNode.next = node
        }
        while sums.next != nil {
            print(sums.val)
            sums = sums.next!
        }
        print(sums.val)
        return sums
    }
}
let lnode1 = ListNode(0)
        let lnode2 = ListNode(1)
        lnode1.next = lnode2
        let lnode3 = ListNode(2)
        lnode2.next = lnode3
        let lnode4 = ListNode(3)
        lnode3.next = lnode4
        let lnode5 = ListNode(4)
        lnode4.next = lnode5
        let lnode6 = ListNode(5)
        lnode5.next = lnode6
        let lnode7 = ListNode(6)
        lnode6.next = lnode7
        let lnode8 = ListNode(7)
        lnode7.next = lnode8
        let lnode9 = ListNode(8)
        lnode8.next = lnode9
        
        let rnode1 = ListNode(6)
        let rnode2 = ListNode(6)
        rnode1.next = rnode2
        let rnode3 = ListNode(7)
        rnode2.next = rnode3
        let rnode4 = ListNode(8)
        rnode3.next = rnode4
        let rnode5 = ListNode(9)
        rnode4.next = rnode5
        
        let _ = Solution.addTwoNumbers(lnode1, rnode1)