思路：

方法一：

1、创建一个新链表用于存放结果 listnode* head=new listnode(-1)

2、需要对进位进行判断 bool carry=false

3、对两个链表是否为空进行判断

4、只要有一个链表不为空，直接对应指针的val相加

5、判断是否有进位，carry=sum>=10?true:false   有进位的话就sum++,h->next=new listnode(sum%10)

6、最后还需要进行最后一位的判断是否有carry ，如果有需要扩充链表并且加一： h->next=new listnode(1)

方法二：

1、对链表长度进行判断，如果不一样长需要对其尾部插入0作为补充 p->next=new listnode(0)

2、创建一个新链表用于存放结果 listnode* head=new listnode(-1)

3、需要对链表重新归置，因为前面的遍历是指针指向了最后一个val，通过链表重新赋值，使指针从头开始，否者只会输出一个最后一个指针的对应的val相加

4、需要对进位进行判断 bool carry=false

5、只要有一个链表不为空，对应指针的val相加

5、判断是否有进位，carry=sum>=10?true:false   有进位,h->next=new listnode(sum%10)

6、最后还需要进行最后一位的判断是否有carry ，如果有需要扩充链表并且加一： h->next=new listnode(1)

 

/**
 * 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* head=new ListNode(-1);//创建一个新链表用于存放结果
    //    ListNode* h=head;
    //    int sum=0;
    //    bool carry=false;//进位判断
    //    while(l1!=NULL || l2!=NULL) //只要链表不为空就可以有新的结果
    //    {
    //        sum=0;
    //        if(l1!=NULL)
    //        {
    //            sum +=l1->val;
    //            l1=l1->next;
    //        }
    //        if(l2!=NULL)
    //        {
    //            sum+=l2->val;
    //            l2=l2->next;
    //        }
    //        if(carry) sum++;//如果有进位
    //        h->next=new ListNode(sum%10);
    //        h=h->next;
    //        carry=sum>=10?true:false;
    //    }
    //    if(carry)
    //    {
    //        h->next=new ListNode(1);
    //    }
    //    return head->next;



    //方法二：
        //获取链表长度
        //在较短的链表末尾补0
        //对齐相加然后考虑进位
        int len1=1;
        int len2=1; //用于记录两个链表长度，由于链表自身存在指针占用一个字节
        ListNode* p1=l1;
        ListNode* p2=l2;
        while(p1->next!=NULL)
        {
            len1++;
            p1=p1->next;
        }
        while(p2->next!=NULL)
        {
            len2++;
            p2=p2->next;
        }
        if(len1>len2)
        {
            for(int i=1;i<=len1-len2;i++)
            {
                p2->next=new ListNode(0);
                p2=p2->next;
            }
        }
        else
        {
            for(int i=1;i<=len2-len1;i++)
            {
                p1->next=new ListNode(0);
                p1=p1->next;
            }
        }
        p1=l1; 
        p2=l2;  //这两步非常重要，因为前面的遍历是指针指向了最后一个val，通过链表重新赋值，使指针从头开始，否者只会输出一个最后一个指针的对应的val相加
        bool count=false;
        ListNode *pre;
        ListNode* l3=new ListNode(-1);
        ListNode* w=l3;
        int sum=0;
        while(p1!=NULL && p2!=NULL)
        {
            sum=count+p1->val+p2->val;
            w->next=new ListNode(sum%10);
            count=sum>=10?true:false;
            w=w->next;
            p1=p1->next;
            p2=p2->next;
        }
        if(count)  //若最后还有进位
        {
            w->next=new ListNode(1);
            w=w->next;
        }
        return l3->next;
    }
};