LeetCode-Add Two Numbers题目解析

这是个在leetcode上中等难度的题目，我搞了好半天，最终以一种原始的方法弄出来了，我把它贴出来供大家参考，我是一个研究生，没有实际的工作经验，写的不好请大家多多包涵。

看题目：

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

百度翻译如下：

您将得到两个非空链表，表示两个非负整数。数字以相反的顺序存储，每个节点都包含一个数字。将两个数字相加，并以链表形式返回总和。

您可以假设这两个数字不包含任何前导零，除了数字0本身。原链接：https://leetcode.com/problems/add-two-numbers/

这个题目的意思是：两个链表中存有一些数据，但这些数据是反向存储的，我们要把它们相加起来然后存储到一个新链表中返回。例如：123 + 123，这两个在链表中是3->

2->1，3->2->1，如果最后一个数有进位的话，返回的链表中要新增一位。例：999+1，最后返回的时候是1000，就是要增加一位，但是显示的时候是0001，因为在链表中

是反向存储的，话不多说，下面就是具体的代码：

/**
 * 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 i = 0; //标志位
        ListNode* sumPtr=new ListNode;
        ListNode* sumptrTemp = sumPtr;
        ListNode* temp1 = l1;
        ListNode* temp2=l2;
        int sum=0;
        int tempL=0;// 存放进位

        while(temp1!=nullptr&&temp2!=nullptr)
        {
            int t1=temp1->val;
            int t2=temp2->val;
            sum=t1+t2;
            int temp=0;
            if(i==0)  //如果是第一个数字相加，那就不用管进位的问题
            {
                if(sum==10)  //首先判断两个数相加是不是10
                {
                temp=sum/10;
                tempL=1;
                sum =0;
                }
            else if(sum>10) //判断两个个位数相加是不是大于10
                {
                temp=sum%10;
                tempL=1;  //进一
                sum=temp;
                }
                sumptrTemp->val=sum;
                sumptrTemp->next=nullptr;
                i++;
            }
            else
            {
                if(tempL!=0)
                {
                    sum=sum+1;
                }
            if(sum==10)  //首先判断两个数相加是不是10
                {
                temp=sum/10;
                tempL=1;
                sum =0;
                }
            else if(sum>10) //判断两个个位数相加是不是大于10
                {
                temp=sum%10;
                tempL=1;  //进一
                sum=temp;
                }
            else  //如果不进位
                {
                    tempL=0;
                }
                ListNode* temp = new ListNode;
                temp->val=sum;
                sumptrTemp->next=temp;
                sumptrTemp=temp;
                temp=nullptr;
            }
            if(temp1->next==nullptr&&temp2->next==nullptr)//长度相等，且最后一位相加也要进位
            {
                if(tempL!=0)
                {
                    ListNode* lastNode=new ListNode;
                    lastNode->val=1;
                    lastNode->next=nullptr;
                    sumptrTemp->next=lastNode;
                    sumptrTemp=sumptrTemp->next;
                    std::cout<<lastNode->val;
                }
            }
            temp1=temp1->next;
            temp2=temp2->next;
            
        }  
            while(temp1!=nullptr) //如果两个链表不是一样长的话，就是左边那个链表比较长
            {
                //std::cout<<"kk"<<" ";
                ListNode *Temp=temp1;
                if(tempL!=0)
                {
                    Temp->val+=tempL;
                    if(Temp->val==10)
                    {
                        Temp->val=0;
                        tempL=1;
                        std::cout<<Temp->val<<" ";
                    }
                    else if(Temp->val<10)
                    {
                         std::cout<<"没有了进位了";
                        tempL=0;
                    }
                    else
                    {
                        tempL=0;
                        std::cout<<"没有了kk";
                        break;
                    }
                }
                else //如果没有进位的话，直接退出
                {
                    std::cout<<"没有了";
                    //break;
                }
                ListNode* Temp2= new ListNode;
                Temp2->val=Temp->val;
                Temp2->next=nullptr;
                sumptrTemp->next=Temp2;
                sumptrTemp=sumptrTemp->next;
                if(temp1->next==nullptr) //如果是最后一个节点了
                {
                    if(tempL==1)//如果前面还有进位的话
                    {
                        ListNode* lastNode=new ListNode;
                        lastNode->val=1;
                        lastNode->next=nullptr;
                        sumptrTemp->next=lastNode;
                        sumptrTemp=sumptrTemp->next;
                        std::cout<<lastNode->val;
                    }
                     else if(Temp->val<10)
                    {
                         std::cout<<"没有了进位了";
                        tempL=0;
                    }
                    else
                    {
                        std::cout<<"前面没有进位了";
                    }
                }
                temp1=temp1->next;
                
                
            }
            while(temp2!=nullptr) //如果两个链表不是一样长的话,如果是第二个链表长的话
            {
                
               std::cout<<"kk2"<<" ";
                if(temp2->next!=nullptr)
                {
                    ListNode *Temp=temp2;
                    if(tempL!=0)
                    {
                        Temp->val+=tempL;
                        if(Temp->val==10)
                        {
                            Temp->val=0;
                            tempL=1;
                            //std::cout<<Temp->val<<" ";
                        }
                        else if(Temp->val<10)
                        {
                            std::cout<<"没有了进位了";
                            tempL=0;
                        }
                        else
                        {
                            tempL=0;
                            //break;
                        }
                    }
                    else //如果没有进位的话，直接退出
                    {
                        std::cout<<"没有了2";
                        //break;
                    }
                     ListNode* Temp2= new ListNode;
                    Temp2->val=Temp->val;
                    Temp2->next=nullptr;
                    sumptrTemp->next=Temp2;
                    sumptrTemp=sumptrTemp->next;
                }
               
               
                else if(temp2->next==nullptr) //如果是最后一个节点了
                {
                    std::cout<<"最后一个节点2";
                    if(tempL==1)//如果前面还有进位的话
                    {
                        ListNode* lastNode2=nullptr;
                        ListNode* lastNode=new ListNode;
                        lastNode->val=temp2->val+tempL;
                        if(lastNode->val==10)
                        {
                             cout<<"又要多加一个"<<endl;
                             lastNode->val=0;
                             lastNode2=new ListNode;
                             lastNode2->val=1;
                             lastNode2->next=nullptr;
                            
                        }
                        lastNode->next=nullptr;
                        sumptrTemp->next=lastNode;
                        sumptrTemp=sumptrTemp->next;
                        sumptrTemp->next=lastNode2;
                        sumptrTemp=sumptrTemp->next;
                        //std::cout<<lastNode->val;
                    }
                    else //如果前面没有进位
                    {
                        sumptrTemp->next=temp2;
                        sumptrTemp=sumptrTemp->next;
                        sumptrTemp->next=nullptr;
                    }
                }
                temp2=temp2->next;
            }
        
        
     
        return sumPtr;
    }
};

上面的代码其实也有问题，有太多的临时节点没有释放，我之后会改进的。leetcode给的评价是

内存占用太高了，毕竟还是有很多重复代码和内存没有释放，接下来我会继续改进的，如果大家有什么问题可以一起交流下。