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

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

解題思路：

本題的難點主要在於輸入為指定的類，另外是相加時注意後一位的進位。
先寫測試程式碼，分別為List和ListNode互相轉換，便於輸入和輸出：

def listToListnode(list):
    prevNode = None
    for i in range(len(list) - 1, -1, -1):
        nextNode = ListNode(list[i])
        nextNode.next = prevNode
        prevNode = nextNode
    return nextNode
listToListnode

def listnodeToList(listnode):
    list = []
    while listnode != None:
        list.append(listnode.val)
        listnode = listnode.next
    return list
 

解題思路1：

其實理解了指定類後，本題的難度很小，只是普通的加法：

listResult = []
addOne = False
while l1 != None or l2 != None:
    if l1 == None:
        val1 = 0
    else:
        val1 = l1.val
    if l2 == None:
        val2 = 0
    else:
        val2 = l2.val
    sum = val1 + val2 + int(addOne)
    addOne = False
    if sum >= 10:
        sum = sum - 10
        addOne = True
    listResult.append(sum)
    if l1!= None:
        l1 = l1.next
    if l2!= None:
        l2 = l2.next
if addOne:
    listResult.append(1)
# print(listResult)
prevNode = None
for i in range(len(listResult) - 1, -1, -1):
    nextNode = ListNode(listResult[i])
    nextNode.next = prevNode
    prevNode = nextNode
return nextNode
 

116 ms，打敗了68.97%的對手。
我的演算法多次判斷了是否為None，以及放到陣列其實也是多餘的行為，如果能直接放進ListNode，不用轉陣列就好了。

解題思路2：

看了LeetCode官方思路，它使用了遞迴。改成和官方相同的思路為：

addOne = False
initNode = ListNode(1)
listNode = initNode
while l1 != None or l2 != None:
    if l1 == None:
        val1 = 0
    else:
        val1 = l1.val
    if l2 == None:
        val2 = 0
    else:
        val2 = l2.val
    sum = val1 + val2 + int(addOne)
    addOne = False
    if sum >= 10:
        sum = sum - 10
        addOne = True
    listNode.next = ListNode(sum)
    listNode = listNode.next
    if l1!= None:
        l1 = l1.next
    if l2!= None:
        l2 = l2.next
if addOne:
    listNode.next = ListNode(1)
return initNode.next

164 ms，打敗了30.60%的對手。
[沉思]，看來陣列還是個比較便捷的演算法，比新建類好用。