刷题：力扣2. Add Two Numbers

网址：leetcode.com/problems/ad…

描述：

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.

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

 * 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 flag1=0,l1len=0,l2len=0;
        ListNode* l11=l1;
        ListNode* l22=l2;
        ListNode* list1;
        ListNode* list2;
        ListNode* lend=new ListNode(1);//相加的和最高位需要进位的情况。
        
        while(l11!=nullptr)
        {
            l1len++;                   //链表l1的长度
            l11=l11->next;              
        }
        while(l22!=nullptr)
        {
            l2len++;                   //链表l2的长度
            l22=l22->next;
        }
        if(l1len>=l2len)
        {
            list1=l1;                  //使list1为长度较长的那一个链表
            list2=l2;
        }
        else
        {
            list1=l2;
            list2=l1;
        }
        
        while(list2!=nullptr)           //从较短的list2开始相加
        {
            int a=list1->val;
            int b=list2->val;
            if((a+b+flag1)>=10)         //需要进位的情况
            {
                list1->val=a+b+flag1-10;  //进位后的和
                flag1=1;                  //flag1表示要进1
            }
            else{
                list1->val=a+b+flag1;     //不需要进位
                flag1=0;
            }
            if(list2->next==nullptr)      //当list2遍历完后结束
                break;
            list1=list1->next;
            list2=list2->next;
        }
        if(l1len==l2len)                  //长度相等时，不需要再加list1多出来的那部分结点了
        {
            if(flag1>0)                   //最高位还需要进位
            {
                 list1->next=lend;    
            }
            return l1;
        }
        list1=list1->next;                //还需要加list1比list2长的那部分
        while(list1!=nullptr)
        {
            int a=list1->val;
            if((a+flag1)>=10)              //需要进位
            {
                list1->val=a+flag1-10;
                flag1=1;
            }
            else{
                list1->val=a+flag1;
                flag1=0;
            }
            if(list1->next==nullptr)
                break;
            list1=list1->next;
        } 
        
        if(flag1>0)                       //最高位还需要进位
        {
            list1->next=lend;    
        }
        if(l1len>=l2len)      //返回较长的那个链表，始终是以list1为基础修改的，list1是较长的那个链表
        return l1;
        else return l2;
    }
};

总结：

简单的模拟，写的很繁琐，需要考虑进位和长度不一样导致的问题。