LeetCode 两数相加（链表）

思路：因为链表的表示是逆序的，所以思路就是模拟两个数从个位相加的操作。考虑上进位。
解法1： 首先我的想法是尽量利用现有的结点，通过改变结点值和指点的指向，因为题目里说了都是非空链表，所以我选择将l1链表作为最后返回的链表。然后分为了三种情况进行考虑，具体解释在代码注释里。

代码：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* head=l1;  //返回的头结点
        ListNode* pre1=NULL;  //遍历l1链表时当前节点的前一结点
        ListNode* pre2=NULL;  //遍历l2链表时当前节点的前一结点
        int jw=0;  //进位
        while(l1&&l2){ //当l1和l2都不为空的时候就相加，然后把结果赋值在l1结点上，并记录进位
            int sum=l1->val+l2->val+jw;
            jw=sum/10;
            l1->val=sum%10;
            pre1=l1;
            pre2=l2;
            l1=l1->next;
            l2=l2->next;
        }
        if(!l1&&l2){ //当l2长度大于11时
            if(jw){  //考虑最后一次相加时的进位
                int sum=l2->val+1; 
                l2->val=sum%10;
                jw=sum/10;
            }
            pre1->next=l2; //此时pre1指向l1的最后一个结点，将这个节点指向l2长度刚多于l1的第一个结点
            pre2=l2;
            l2=l2->next;
            while(jw&&l2){ //考虑进位，所以要将剩下的l2中的结点遍历
                int sum=l2->val+1;
                l2->val=sum%10;
                jw=sum/10;
                pre2=l2;
                l2=l2->next;
            }
            if(jw&&!l2){ //如果最后一个结点遍历计算完后还有进位
                pre2->next=new ListNode(1);
            }
        }else if(l1&&!l2){ //当l1长度大于12时，就无须更改l1结点中的指向了
            while(jw&&l1){ //同上
                int sum=l1->val+1;
                l1->val=sum%10;
                jw=sum/10;
                pre1=l1;
                l1=l1->next;
            }
            if(jw&&!l1){  //同上
                pre1->next=new ListNode(1);
            } 
        }
        else{ //当l1长度等于12时，只用考虑最后还是否有进位
            if(jw){
                pre1->next=new ListNode(1);
            }
        }
        return head;
    }
};

解法2： 解法1写起来确实太冗长，然后我看了官方题解，他就没有考虑空间利用的问题，直接每相加一次就new一个新的结点，思路也很清晰，就是从头到尾遍历两个链表，如结点存在，就用结点的值进行求和，若结点为空，则用0来代替求和，注意的是这里需要一个虚拟头结点，这样的目的是能让在while循环中生成的新节点能够被链接。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* vhead=new ListNode(-1);
        ListNode* cur=vhead;
        int carry=0;
        while(l1||l2){
            int val1=(l1)?l1->val:0;
            int val2=(l2)?l2->val:0;
            int sum=val1+val2+carry;
            carry=sum/10;
            ListNode* newNode=new ListNode(sum%10);
            cur->next=newNode;//当前节点指向新创建的结点
            cur=cur->next;
            if(l1){ //注意这里要进行非空的判断
                l1=l1->next;
            }
            if(l2){ //同上
                l2=l2->next;
            }
            
        }
        if(carry){  //最后再判断一次进位
            cur->next=new ListNode(carry);
        }
        return vhead->next;
    }
};

方法一空间复杂度是O(1)
方法二的空间复杂度为O(max(m,n))，其中m，n为两条链表的长度
时间复杂度都是O(m+n)，因为都要把两条链表遍历一次。