2. 两数相加

最开始的思路是将链表转换为整数，进行相加后再转换回链表。

第一次的写法如下，测试用例全部通过，提交的时候傻眼了：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) 
    {
        if(l1->val == 0 || l2->val == 0)
        {
            if(l1->val == 0)
                return l2;
            else
                return l1;
        }
        long long  num1  = 0;
        int epoch1 = 1;
        while(l1!=nullptr)
        {
            num1 += l1->val*epoch1;
            epoch1 *= 10;
            l1 = l1->next;
        }
        long long num2  = 0;
        int epoch2 = 1;
        while(l2!=nullptr)
        {
            num2 += l2->val*epoch2;
            epoch2 *= 10;
            l2 = l2->next;
        }
        long long total = num1 + num2;
        ListNode* dummyhead = new ListNode;
        ListNode* r = dummyhead;
        while(total != 0)
        {
            ListNode* p = new ListNode(total%10);
            r->next = p;
            r = p;
            total /= 10;
        }
        return dummyhead->next;
    }

};

又看了一遍题意，发现可能有一百个长度的链表相加，因此这种方法根本不可能AC。

• 重新设计思路

我们可以参考加法器的实现思路来解决该问题。逐位相加，考虑进位问题。具体步骤如下：

1. 初始化一个虚拟头节点 dummyHead 和一个当前节点 cur 指向虚拟头节点。初始化进位 carry 为 0。
2. 遍历两个链表，逐位相加。如果某个链表遍历完了，则对应位置的值设为 0。 计算当前位的和 sum，以及新的进位
   carry。创建一个新的节点存储 sum % 10 的结果，并将其加入到结果链表中。 更新当前节点 cur，并将指针移到下一个节点。

第二次写法如下，还是没有全部AC。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) 
    {
        ListNode* dummyhead = new ListNode(0);
        ListNode *q=l2,*p=l1,*cur = dummyhead;
        int carry = 0;
        while(p || q)
        {
            int x = p ? p->val:0;
            int y = q ? q->val:0;
            int sum = carry + x + y;
            carry = sum/10;
            ListNode* tmp = new ListNode(sum%10);
            cur->next = tmp;
            cur = tmp;
            if(p!=nullptr)
            {
                p = p -> next;
            }
            if(q!=nullptr)
            {
                q = q -> next;
            }
        }
        return dummyhead->next;   
    }
};

查看错误测试用例发现，原因是while循环结束后，进位还有一个1，因此还需要插入一个节点。
如果遍历完链表后仍然有进位，需要创建一个新节点存储这个进位值，并将其加入到结果链表的末尾。

最终解法如下:

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) 
    {
        ListNode* dummyhead = new ListNode(0);
        ListNode *q=l2,*p=l1,*cur = dummyhead;
        int carry = 0;
        while(p || q)
        {
            int x = p ? p->val:0;
            int y = q ? q->val:0;
            int sum = carry + x + y;
            carry = sum/10;
            ListNode* tmp = new ListNode(sum%10);
            cur->next = tmp;
            cur = tmp;
            if(p!=nullptr)
            {
                p = p -> next;
            }
            if(q!=nullptr)
            {
                q = q -> next;
            }
        }
        if(carry > 0)
        {
            ListNode* tmp = new ListNode(carry);
            cur->next = tmp;
            cur = tmp;
        }
        return dummyhead->next;   
    }
};