力扣刷题记录-第二题-两数相加

一、题目:

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

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

你可以假设除了数字 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
• 题目数据保证列表表示的数字不含前导零

二、解题思路及代码:

第一种，迭代法。迭代遍历两个链表，依次相加，相加若超过10，记录其个位数和十位数。用一个int类型变量next1记录十位数，十位数要加到下一位。可能会出现l1和l2两个链表长度不一致的情况，遍历完公共部分后再分别判断。除此之外，可能l1和l2最后一位相加超过10，因此最后还要加一个判断，若最后一位相加超过10要给结果链表在添加一个node。代码如下：

(ps，我们新建一个listnode节点result，这个result指向一个空的开头节点，从result.next开始才有val值，因此返回result.next。题目中的l1和l2是直接指向数字的。)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int total=0;
        int next1=0;
        ListNode result=new ListNode();
        ListNode cur = result;
        while(l1!=null && l2!=null){
            total=l1.val+l2.val+next1;
            next1=total/10;
            cur.next=new ListNode(total%10);
            l1=l1.next;
            l2=l2.next;
            cur=cur.next;
        }
        while(l1!=null){
            total=l1.val+next1;
            next1=total/10;
            cur.next=new ListNode(total%10);
            l1=l1.next;
            cur=cur.next;
        }
        while(l2!=null){
            total=l2.val+next1;
            next1=total/10;
            cur.next=new ListNode(total%10);
            l2=l2.next;
            cur=cur.next;
        }
        if(next1!=0){
            cur.next=new ListNode(next1);
        }
        return result.next;
    }
}

第二种，递归法。将当前的l1和l2的值相加之后，保留个位数放在result里，但是next1的值不能传到下一层，因此将next1的值直接加在下一层的l1或l2的值上。若l1或l2的下一层为空，直接新建一个值为0的listnode给l1和l2的下一层。递归的终止条件是：l1为空,l2为空,并且next1等于0，递归才会终止。代码如下:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int total = l1.val+l2.val;
        ListNode result=new ListNode(total%10);
        int next1=total/10;
        if(l1.next!=null || l2.next!=null || next1!=0){
            if(l1.next!=null){
                l1=l1.next;
            }
            else{
                l1=new ListNode(0);
            }
            
            if(l2.next!=null){
                l2=l2.next;
            }
            else{
                l2=new ListNode(0);
            }

            l1.val=l1.val+next1;
            result.next=addTwoNumbers(l1, l2);
        }

        return result;
    }
}

在使用迭代法时，我第一次写的代码出现了差错，将终止条件下的代码写成了如下。

这样犯了一个错误，l1和l2为空的时候，他们的next也为空，我又直接在这个空上进行赋值0的操作。到这里，就能想明白我们对l1和l2进行赋值0结点的操作这一步，与l1和l2之前的链表没有.next关系，是断开的链表节点，只在这次递归中用一下。

        if(l1.next!=null || l2.next!=null || next1!=0){
            if(l1.next!=null){
                l1=l1.next;
            }
            else{
                l1.next=new ListNode(0);
            }
            
            if(l2.next!=null){
                l2=l2.next;
            }
            else{
                l2.next=new ListNode(0);
            }

            l1.val=l1.val+next1;
            result.next=addTwoNumbers(l1, l2);
        }