LintCode 链表求和

1.描述

你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，

使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。

样例

给出两个链表 3->1->5->null 和 5->9->2->null，返回 8->0->8->null

2.分析

第一眼看过去觉得这个题目把数字倒着分解开存储到链表中是增加难度，但实际上是减小了，

因为第一个节点是个位第二个是十位，按照从小到大的顺序排列加和就分别从两个链表中取出

相应位数甲相加，有进位就加入到下一个链表中。如果其中一个链表长度大于另一个链表，说明

这个链表位数更大，之后的位数都是这个链表的位数。如122+28，1在百位上因此加和时第三个

节点（百位只要1自己就可以了）。

3.代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /**
     * @param l1: the first list
     * @param l2: the second list
     * @return: the sum list of l1 and l2
     */
    ListNode *addLists(ListNode *l1, ListNode *l2) {
        // write your code here
    int a,b;
    int c=0;
    ListNode *dummy,*rear;
    dummy=new ListNode(0);
    rear=dummy;
    while(l1!=NULL||l2!=NULL)
    {
        if(l1==NULL)
        {
                ListNode *node;
                node=new ListNode(l2->val+c);
                rear->next=node;
                rear=node;
                l2=l2->next;
                c=0;
        }
        else if(l2==NULL)
        {
                ListNode *node;
                node=new ListNode(l1->val+c);
                rear->next=node;
                rear=node;
                l1=l1->next;
                c=0;
                
        }
        else
        {
                a=l1->val+l2->val+c;
                b=a%10;
                c=a/10;
                ListNode *node;
                node=new ListNode(b);
                rear->next=node;
                rear=node;
                l1=l1->next;
                l2=l2->next;
        }
    }
    if(c)
    {
        ListNode *node;
        node=new ListNode(c);
        rear->next=node;
        rear=node;
    }
    return dummy->next;
    }
};

4.总结

这里a,b,c起着重大作用，a就是当前相同位数的元素加和，b为进位后剩下的数（如13进位后剩3），

c为进上去的数（加法中要么进1要么进0即不进位）。b为当前位的数值存入节点中，下一个节点加和

后再加上上一位进过来的c继续做判断，高了就进位剩下的存入节点中。

这里举个例子22+78，百位上没有数，但加和产生了进位，实际上下面位数加完后还给百位进了一个1，最后

百位上是1，这个是需要特殊考虑的（红色代码）。

若没有绿色代码c=0把c清空一下，下面的测试数据

输入

2->8->2->8->2->9->6->4->5->2->5->2->null, 5->8->9->5->6->5->1->8->7->5->5->null

输出

7->6->2->4->9->4->8->2->3->8->0->3->1->null

期望答案

7->6->2->4->9->4->8->2->3->8->0->3->null

这里可以看到最后多了一个1，第一个链表是12位，第二个链表是11位，加和为12位，

但是由于c=1未清空在绿色代码中又执行了一次，因此在链表的最后又加了一个1变为13位

导致错误。

总的来说两个链表位数相等只需要考虑最后会不会进位（红色代码），而如果位数不等也要

考虑进位，进得位加在高位上而不是加在高位后面比高位更高（绿色代码）。