[Swift]LeetCode445. 两数相加 II | Add Two Numbers II

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10339558.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Follow up:
What if you cannot modify the input lists? In other words, reversing the lists is not allowed.

Example:

Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 8 -> 0 -> 7

---

给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。 

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

进阶:

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

示例:

输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 8 -> 0 -> 7

---

64ms

/**
 * Definition for singly-linked list.
 * 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 n1:Int = getLength(l1)
        var n2:Int = getLength(l2)
        var head:ListNode? = ListNode(1)
        head!.next = (n1 > n2) ? helper(l1, l2, n1 - n2) : helper(l2, l1, n2 - n1)
        if head!.next!.val > 9
        {
            head!.next!.val %= 10
            return head
        }
        return head!.next
    }
    
    func getLength(_ head: ListNode?) -> Int
    {
        var head = head
        var cnt:Int = 0
        while(head != nil)
        {
            cnt += 1
            head = head!.next
        }
        return cnt
    }
    
    func helper(_ l1: ListNode?, _ l2: ListNode?,_ diff:Int) -> ListNode?
    {
        if l1 == nil {return nil}
        var res:ListNode? = (diff == 0) ? ListNode(l1!.val + l2!.val) : ListNode(l1!.val)
        var post:ListNode? = (diff == 0) ? helper(l1!.next, l2!.next, 0) : helper(l1!.next, l2, diff - 1)
        if post != nil && post!.val > 9
        {
            post!.val %= 10
            res!.val += 1
        }
        res!.next = post
        return res
    }
}

---

92ms

/**
 * Definition for singly-linked list.
 * 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 array1: [Int] = []
    var array2: [Int] = []
    var array3: [Int] = []
    var list1 = l1, list2 = l2
    
    while list1 != nil {
        array1.append(list1!.val)
        list1 = list1?.next
    }
    
    while list2 != nil{
        array2.append(list2!.val)
        list2 = list2?.next
    }
    
    var flag = 0
    while array1.last != nil || array2.last != nil {
        var sum = (array1.popLast() ?? 0) + (array2.popLast() ?? 0) + flag
        if sum >= 10{
            flag = 1
            sum = sum - 10
        }else{
            flag = 0
        }
        array3.append(sum)
    }
    if flag == 1{
        array3.append(1)
    }
    let list3: ListNode? = ListNode(-1)
    var list4 = list3

    while array3.last != nil{
        list4?.next = ListNode(array3.popLast()!)
        list4 = list4?.next
    }
    return list3?.next
 }
}

---

100ms

/**
 * Definition for singly-linked list.
 * 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? {
        guard let l1 = l1, l1.val != 0 else {
            return l2
        }

        guard let l2 = l2, l2.val != 0 else {
            return l1
        }

        var next: ListNode? = l1
        var nums1: [Int] = []
        while next != nil {
            nums1.append(next!.val)
            next = next?.next
        }

        var next2: ListNode? = l2
        var nums2: [Int] = []
        while next2 != nil {
            nums2.append(next2!.val)
            next2 = next2?.next
        }

        let loopCount = max(nums1.count, nums2.count)
        next = l1
        if nums1.count < nums2.count {
            let temp = nums2
            nums2 = nums1
            nums1 = temp
            next = l2
        }

        let count = nums1.count

        for index in 0..<loopCount {
            var num2 = 0
            let index2 = nums2.count - 1 - index
            if index2 >= 0 {
                num2 = nums2[index2]
            }

            let sum = nums1[nums1.count - 1 - index] + num2
            if sum >= 10 {
                nums1[nums1.count - 1 - index] = sum % 10
                if nums1.count - 2 - index < 0 {
                    nums1.insert(1, at: 0)
                } else {
                    nums1[nums1.count - 2 - index] += 1
                }
            } else {
                if index2 < 0 {
                    break
                }
                
                nums1[nums1.count - 1 - index] = sum
            }
        }

        var root: ListNode!
        var index = 0
        if count < nums1.count {
            root = ListNode(nums1[0])
            root.next = next
            index = 1
        } else {
            root = next
        }

        while index < nums1.count {
            next?.val = nums1[index]
            next = next?.next
            index += 1
        }

        return root
    }
}

---

124ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reverse(_ list: ListNode?) -> ListNode?{
    var l1 = list
    var pre: ListNode? = nil
    while l1 != nil {
        let temp = l1?.next
        l1?.next = pre
        pre = l1
        l1 = temp
    }
    return pre
}
    
func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode?       {
    let list1 = self.reverse(l1)
    let list2 = self.reverse(l2)
    let list3: ListNode? = ListNode(-1)
    
    var ll1 = list1, ll2 = list2, ll3 = list3
    var flag = 0
    while ll1 != nil || ll2 != nil{
        let ll1value = ll1?.val ?? 0
        let ll2value = ll2?.val ?? 0
        var sum = ll1value + ll2value + flag
        if sum >= 10{
            flag = 1
            sum = sum - 10
        }else{
            flag = 0
        }
        ll3?.next = ListNode(sum)
        ll3 = ll3?.next
        ll2 = ll2?.next
        ll1 = ll1?.next
    }
    if flag == 1{
        ll3?.next = ListNode(1)
    }
    return self.reverse(list3?.next)
  }
}

---

156ms

/**
 * Definition for singly-linked list.
 * 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 rl1 = reverseList(l1)
        var rl2 = reverseList(l2)
        
        var rres = addTwoNumbers1(rl1, rl2)
        
        return reverseList(rres)
    }
    
    func reverseList(_ head: ListNode?) -> ListNode? {
        var cur = head
        var pre: ListNode? = nil
        
        while cur != nil {
            var next = cur!.next
            cur!.next = pre
            pre = cur
            cur = next
        }
        
        return pre
    }
    
    func addTwoNumbers1(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        var cur1 = l1
        var cur2 = l2
        var head: ListNode? = nil
        var pre: ListNode? = nil
        
        var carryBit = 0
        
        while cur1 != nil || cur2 != nil {
            var sum: Int;
            if cur1 != nil && cur2 != nil {
                sum = cur1!.val + cur2!.val + carryBit
                cur1 = cur1!.next
                cur2 = cur2!.next
            } else if cur1 != nil && cur2 == nil {
                sum = cur1!.val + carryBit
                cur1 = cur1!.next
            } else {
                sum = cur2!.val + carryBit
                cur2 = cur2!.next
            }
            
            carryBit = sum / 10
            let reminder = sum % 10
            
            let newNode = ListNode(reminder)
            
            if pre == nil {
                head = newNode
            } else {
                pre?.next = newNode
            }
            
            pre = newNode
        }
        
        if carryBit > 0 {
            let newNode = ListNode(carryBit)
            pre?.next = newNode
        }
        
        return head
    }
}

---

224ms

/**
 * Definition for singly-linked list.
 * 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 ls1Count = self.getListNodeArray(l1);
        var ls2Count = self.getListNodeArray(l2);
        var maxCount = max(ls1Count.count, ls2Count.count)
        var carry = 0
        var startNode : ListNode?
        var nextNode : ListNode?
        for i in 0..<maxCount{
            
            if(i >= ls1Count.count || i >= ls2Count.count)
            {
                var val : Int = carry
                if(i >= ls1Count.count)
                {
                    val  += ls2Count[i]
                }
                else
                {
                    val  += ls1Count[i]
                }
                if(val >= 10 )
                {
                    val = val % 10
                    carry = 1
                }
                else {
                    carry = 0
                }
                let node = ListNode.init(val)
                nextNode?.next = node
                nextNode = node;
                print(val);
            }
            else
            {
                var val = ls2Count[i] + ls1Count[i] + carry
                if(val >= 10 )
                {
                    val = val % 10
                    carry = 1
                }
                else {
                    carry = 0
                }
                print(val);
                let node = ListNode.init(val);
                if(startNode  == nil)
                {
                    startNode = node;
                }
                else
                {
                    nextNode!.next = node;
                }
                nextNode = node;
                
            }
        }
        if(carry == 1)
        {
            let node = ListNode.init(1);
            nextNode?.next = node;
        }
        let des  = self.getListNodeArray(startNode);
        var next2Node : ListNode?
        var start2Node : ListNode?
        for val in des{
                
            let node = ListNode.init(val);
            if(start2Node  == nil)
            {
                start2Node = node;
            }
            else
            {
                next2Node!.next = node;
            }
            next2Node = node;
            
        }
        
        return start2Node;
        
    }
    
    
    func getListNodeArray(_ ls : ListNode?) -> [Int] {
        var lsCount :[Int] = []
        var nls = ls;
        while( nls != nil  )
        {
            lsCount.append(nls?.val as! Int)
            nls = nls?.next
        }
        
        var desCount : [Int] = []
        for (index,value) in lsCount.enumerated().reversed() {
            
            desCount.append(value)
         
        }
        
        return desCount
    }
}