LeetCode算法题2：两数相加解析

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
示例:

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

这个题要是对链表不太熟悉的话会挺吃力，其实算法还是很简单的，只是需要注意的点有些多。首先两个链表是不一定等长的；第二要注意进位问题；第三如果循环相加并产生节点的话最后如果不加额外判断会多出一个节点，或者开头得设置一个哑节点。所以大致思路如下：
先创建一个新列表，然后创建一个指针指向它，否则最后返回的指针一定是指向NULL。然后循环检测当前的两个列表的指针是否为空，如果为空说明列表遍历完成，只要有一个列表不为空就继续循环；循环体内判断列表不为空就将其值加起来赋给新列表的节点，且在列表不为空时判断一下这两个列表的下一个指向是否为空，如果都为空说明不需要再创建节点了，如果有任意一个不为空就需要继续创建节点；另外如果两数与进位相加大于10就需要设置进位，而且最后执行的那次循环如果有进位则需要再创建一个节点，所以循环之外需要判断进位来决定是否创建新节点。
C++程序如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* list = new ListNode(0);
        ListNode * p = l1, * q = l2, * curr = list;
        int carry = 0;
        int temp = 0;
        int creatNode = 0;
        while(p!=NULL || q!=NULL)
        {
            int x = (p!=NULL)?p->val:0;
            int y = (q!=NULL)?q->val:0;
            temp = x + y + carry;
            if(temp >= 10)
            {
                carry = 1;
                temp = temp - 10;
                curr->val = temp;
            }
            else
            {
                carry = 0;
                curr->val = temp;
            }
            if(p!=NULL)
            {
                if(p->next!=NULL)
                    creatNode = 1;
                p = p->next;
            }
            if(q!=NULL)
            {
                if(q->next!=NULL)
                    creatNode = 1;
                q = q->next;
            }
            if(creatNode)
            {
                curr->next = new ListNode(0);
                curr = curr->next;
                creatNode = 0;
            }
        }
        if(carry > 0)
        {
            curr->next = new ListNode(carry);
        }
        return list;
        
    }
};

python3程序如下（python3做了一点程序简化，但是过程都是一样的）：

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

class Solution:
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        l3 = ListNode(0)
        p, q=l1, l2
        curr = l3
        carry = 0
        creatNode = 0
        while p!=None or q!=None:
            if p!=None:
                x = p.val
                if p.next!=None:
                    creatNode = 1
                p = p.next
            else:
                x = 0
            if q!=None:
                y = q.val
                if q.next!=None:
                    creatNode = 1
                q = q.next
            else:
                y = 0
            temp = x + y + carry
            carry = 0
            if temp >= 10:
                temp = temp - 10
                carry = 1
            else:
                carry = 0
            curr.val = temp
            if creatNode == 1:
                curr.next = ListNode(0)
                curr = curr.next
                creatNode = 0
        if carry > 0:
            curr.next = ListNode(carry)
        
        return l3
        

这个程序的时间复杂度为O(m,n)，mn分别为l1，l2的长度，空间复杂度就是O(max(m,n))