力扣——两数相加

**错误解法 **

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int len1=1;//记录l1的长度
        int len2=1;//记录l2的长度
        ListNode* p=l1;
        ListNode* q=l2;
        while(p->next!=NULL)//获取l1的长度
        {
            len1++;
            p=p->next;
        }
        while(q->next!=NULL)//获取l2的长度
        {
            len2++;
            q=q->next;
        }
        if(len1>len2)//l1较长，在l2末尾补零
        {
            for(int i=1;i<=len1-len2;i++)
            {
                q->next=new ListNode(0);
                q=q->next;
            }
        }
        else//l2较长，在l1末尾补零
        {
            for(int i=1;i<=len2-len1;i++)
            {
                p->next=new ListNode(0);
                p=p->next;
            }
        }
        p=l1;
        q=l2;

        //思路：就直接在l1上面操作，不开辟新的链表
        //如果相加大于0就l1的下一个节点的val+1
        int t;
        while(p!=NULL)
        {
            t=p->val+q->val;
            if(t>=10)
            {
                if(p->next!=NULL)
                {
                    p->val=t-10;
                    p->next->val+=1;
                }
                else
                {
                    ListNode* p3=new ListNode(1);
                    p->val=t-10;
                    p3->next=p->next;
                    p->next=p3;
                }
            }
            else
            {
                p->val=t;
            }
            p=p->next;
            q=q->next;
        }
        return l1;
    }
};

永远不会跳出来，因为我们在循环里面next为空的时候判断了一次，并且new了下一个，但是我们循环的时候又在判断，所以永远不会结束。

只要最后一位不进位那么就不会报错，如果进位报错那么久会报错！

法1，链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int len1=1;//记录l1的长度
        int len2=1;//记录l2的长度
        ListNode* p=l1;
        ListNode* q=l2;
        while(p->next!=NULL)//获取l1的长度
        {
            len1++;
            p=p->next;
        }
        while(q->next!=NULL)//获取l2的长度
        {
            len2++;
            q=q->next;
        }
        if(len1>len2)//l1较长，在l2末尾补零
        {
            for(int i=1;i<=len1-len2;i++)
            {
                q->next=new ListNode(0);
                q=q->next;
            }
        }
        else//l2较长，在l1末尾补零
        {
            for(int i=1;i<=len2-len1;i++)
            {
                p->next=new ListNode(0);
                p=p->next;
            }
        }
        p=l1;
        q=l2;
        //那我们新开一个链表
        bool count=false;//记录进位
        ListNode* L=new ListNode(0);//存放结果的链表
        ListNode* w=L;//L的移动指针
        int i=0;//记录相加结果
        while(p!=NULL)
        {
            i=count+p->val+q->val;
            w->next=new ListNode(i%10);
            count=i>=10?true:false;
            w=w->next;
            p=p->next;
            q=q->next;
        }
        if(count)//若最后还有进位
        {
            w->next=new ListNode(1);
        }
        return L->next; 
    }
};

法2，递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
    {
       return dfs(l1,l2,0);
    }
public:
    ListNode *dfs(ListNode *l1,ListNode *l2,int temp)
    {
        if(l1==nullptr&&l2==nullptr&&temp==0)
        return nullptr;
        int t=temp+(l1!=nullptr?l1->val:0)+(l2!=nullptr?l2->val:0);
        ListNode *curNode = new ListNode(t%10);
        curNode->next =dfs(l1==nullptr?nullptr:l1->next,l2==nullptr?nullptr:l2->next,t>=10?1:0);
        return curNode;
    }
};