題目描述：

給出兩個非空 的連結串列用來表示兩個非負的整數。其中，它們各自的位數是按照逆序的方式儲存的，並且它們的每個節點只能儲存一位數字。

如果，我們將這兩個數相加起來，則會返回一個新的連結串列來表示它們的和。

您可以假設除了數字 0 之外，這兩個數都不會以 0開頭。

示例：

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

第一次嘗試：

將儲存在連結串列中的數字轉換為int型別的數字，然後將兩個數字相加的加過在按位存貯在連結串列中返回。

注意點：因為儲存在連結串列中的數字可能非常大，那麼在將連結串列中的數字轉換成int型別的時候會超出int型別能夠儲存的範圍，那麼結果就會出錯。

 1 # class ListNode:
 2 #     def __init__(self, x):
 3 #         self.val = x
 4 #         self.next = None
 5 
 6 class Solution:
 7     def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
 8         a = l1.val
 9         i = 1
10         while l1.next != None:
11             l1 = l1.next
 
12             a += l1.val*math.pow(10, i)
13             i += 1
14             # print (a)
15         i = 1
16         b = l2.val
17         while l2.next != None:
18             l2 = l2.next
19             b += l2.val*math.pow(10, i)
20             i += 1
21             # print (b)
22 
23         result = str(int(a + b))[::-1]
 
24         # print (result)
25 
26         l = ListNode(int(result[0]))
27         p = l
28 
29         for i in range(1, len(result)):
30             p.next = ListNode(int(result[i]))
31             p = p.next
32 
33         return l

第二次嘗試：

使用連結串列按位相加。採用一個標誌位flag來表示該次計算有沒有產生進位，如果產生，flag=True，否則flag=False

注意點：1. 位數不相等時的處理方式。 2. 最後一位產生進位時的處理方式。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        flag = False
        l3 = ListNode(0)
        p3 = l3
        while l1!=None and l2!=None:
            if flag == True:
                result = l1.val + l2.val + 1
                # flag = False
            else :
                result = l1.val + l2.val
            if(result >= 10):
                flag = True
                result = result - 10
            else:
                flag = False
            temp = ListNode(result)
            p3.next = temp
            p3 = temp
            l1= l1.next
            l2 = l2.next
        
        if l1 == None and l2 != None:
            while l2 != None:
                if flag == True:
                    result = l2.val + 1
                    # flag = False
                else:
                    result = l2.val
                if (result >= 10):
                    flag = True
                    result = result - 10
                else:
                    flag = False
                temp = ListNode(result)
                p3.next = temp
                p3 = temp
                l2 = l2.next
        if l2 == None and l1 != None:
            while l1 != None:
                if flag == True:
                    result = l1.val + 1
                    # flag = False
                else:
                    result = l1.val
                if (result >= 10):
                    flag = True
                    result = result - 10
                else:
                    flag = False
                temp = ListNode(result)
                p3.next = temp
                p3 = temp
                l1 = l1.next
        if l1 == None and l2 == None:
            if flag == True:
                p3.next = ListNode(1)
        return l3.next

程式碼簡化：

將集中判斷條件，簡化成一種形式。上面那種解法判斷條件多的一個原因是：每種情況我們得到的計算不同。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 建立一個結點值為 None 的頭結點, dummy 和 p 指向頭結點, dummy 用來最後返回, p 用來遍歷
        dummy = p = ListNode(None)          
        s = 0               # 初始化進位 s 為 0
        while l1 or l2 or s:
            # 如果 l1 或 l2 存在, 則取l1的值 + l2的值 + s(s初始為0, 如果下面有進位1, 下次加上)
            s += (l1.val if l1 else 0) + (l2.val if l2 else 0)  
            p.next = ListNode(s % 10)       # p.next 指向新連結串列, 用來建立一個新的連結串列
            p = p.next                      # p 向後遍歷
            s //= 10                        # 有進位情況則取模, eg. s = 18, 18 // 10 = 1
            l1 = l1.next if l1 else None    # 如果l1存在, 則向後遍歷, 否則為 None
            l2 = l2.next if l2 else None    # 如果l2存在, 則向後遍歷, 否則為 None
        return dummy.next   # 返回 dummy 的下一個節點, 因為 dummy 指向的是空的頭結點, 下一個節點才是新建連結串列的後序節點

作者：meng-zhi-hen-n
連結：https://leetcode-cn.com/problems/add-two-numbers/solution/zui-zhi-bai-de-xie-fa-by-meng-zhi-hen-n-2/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/add-two-numbers
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。