两数相加--LeetCode

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 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
    }
}

class Solution {
    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        var carry = 0
        let head = ListNode(0)
        var cur = head, p1 = l1, p2 = l2

        while p1 != nil || p2 != nil {
            if let q1 = p1 {
                carry += q1.val
                p1 = q1.next
            }
            
            if let q2 = p2 {
                carry += q2.val
                p2 = q2.next
            }
            
            let nextNode = ListNode(carry % 10)
            cur.next = nextNode
            cur = nextNode
            carry = Int(carry / 10)
        }
        
        //最高位有进位
        if carry > 0 {
            let node = ListNode(carry)
            cur.next = node
        }
        
        return head.next
    }
}

pic1.png

拓展：
如果链表中的数字不是按逆序存储的呢？例如：
(3→4→2)+(4→6→5)=8→0→7

func addTwoNumbers1(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        var array1 = [Int]()
        var array2 = [Int]()
        var p1 = l1, p2 = l2, carry = 0
        while p1 != nil {
            if let q1 = p1 {
                array1.append(q1.val)
                p1 = p1?.next
            }
        }
        while p2 != nil {
            if let q2 = p2 {
                array2.append(q2.val)
                p2 = p2?.next
            }
        }
        
        var cur: ListNode?
        
        while array1.count > 0 || array2.count > 0 {
            if array1.count > 0 {
                carry += array1.removeLast()
            }
            
            if array2.count > 0 {
                carry += array2.removeLast()
            }
            
            let node = ListNode(carry % 10)
            if cur == nil {
                cur = node
            } else {
                node.next = cur
                cur = node
            }
            
            carry = Int(carry / 10)
        }
        
        if carry > 0 {
            let n = ListNode(carry)
            n.next = cur
        }
        
        return cur
    }