Leetcode 1 两数相加

题目

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
 

提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

/**
 * 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) {}
 * };
 */

 /*
 Code By DavenWoo
 Debug Date:2021/09/09
 */

/*
思路：两个链表相加，涉及链表的基本操作遍历以及进位的问题；
关于进位：需要有一个Flag来表示是否进位，方便进行分支计算，
并对进位进行处理，且因为链表中的每一位数值范围在0-9之间，
即进位最大为1；另外，当两个链表的长度大小相等时，只用对两
个表进行遍历即可；当两个表的大小不等时，要进行分支判别，这
里所用的思路为将两个表中较短的那个来用0来补充。此时还有一点
：在两个表的每一位都为9 时，会出翔一种特殊情况，即最后一位
也会有1的进位，这里的处理是对遍历完成的链表尾部加上一个1即可
*/
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *p=l1,*q=l2;
        int n=1;
        int m=1;
        while(p->next!=NULL){
            n++;
            p=p->next;
        }
        while(q->next!=NULL){
            m++;
            q=q->next;
        }
        if(n>m){
            for(int i=m;i<=n;i++){
                q->next=new ListNode(0);
                q=q->next;
            }
        }else if(n<m){
            for(int i=n;i<=m;i++){
                p->next=new ListNode(0);
                p=p->next;
            }
        }
        p=l1;
        q=l2;
        int t;
        bool flag=false;
        ListNode *l3=new ListNode(-1);
        ListNode *w=l3;
        while(p!=NULL&&q!=NULL){
            ListNode *a=new ListNode(0);
            if(flag){
                t=p->val+q->val+1;
            }else{
                t=p->val+q->val;
            }
            if(t>=10){
                a->val=t%10;
                flag=true;
            }else{
                a->val=t;
                flag=false;
            } 
            w->next=a;
            w=w->next;
            p=p->next;
            q=q->next;  
        }
        if(flag){
            ListNode *a=new ListNode(1);
            w->next=a;
        }
        return l3->next;
    }
};

/**
 * 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) {}
 * };
 */

 /*
 Code By DavenWoo
 Debug Date:2021/09/09
 */

/*
思路：用sum这个变量作为临时存储数据的中转站，对两支链表都进行遍历
，遍历时需要判断是否已经到了结尾处，若未到达链尾，会将该节点的数值
加入到sum中去，并且当发生进位时会直接对sum进行自加操作，相比于开始
的，少了很多的分支判断。
*/
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *q=l1,*p=l2,*l3=new ListNode(-1);
        ListNode *h=l3;
        bool flag=false;
        int sum=0;
        while(q!=NULL||p!=NULL){
            sum=0;
            if(q!=NULL){
                sum+=q->val;
                q=q->next;
            }
            if(p!=NULL){
                sum+=p->val;
                p=p->next;
            }
            if(flag){
                sum++;
            }
            h->next=new ListNode(sum%10);
            h=h->next;
            flag=sum>=10?true:false;
        }
        if(flag){
            h->next=new ListNode(1);
        }
        return l3->next;
    }
};