LeetCode Hot 100 - 002 两数相加

LeetCode Hot 100 必刷必会 - 002 两数相加

地址：2. 两数相加 - 力扣（LeetCode）

题目描述：

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

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

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

输入：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、两个数字不能保证位数相等（比如327和15），那转换到本题中就是 两个链表的长度不等，

处理方式：短链表的缺失位用0代替，不会影响计算结果。

举例：327和15链表表示分别是[7,2,3]和[5,1] ，处理之后就是[7,2,3]和[5,1,0] ,对应数字为327和015，补0不会对结果产生影响。

2、每位相加后存在大于等于10的情况需要进位（注意：不是向前进位，而是向后进位，因为链表是数字逆序）。

处理方式：声明一个数值型变量carry专门存储进位值，再下一次相加时一起累加。 carry = 相加结果sum除以10。同时进位后当前值val = sum除以10取模

// 伪代码
int carry = 0;
// val1和val2分别是两个链表的值
int sum = carry + val1 + val2;
carry = sum/10;
val = sum%10;

举例：327和15相加 7+5=12； carry = 11/10 =1; val = 12%10=2; 

解法一：

/**
 * 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 carry = 0;
        ListNode node = new ListNode(0);
        ListNode pre = node;
        while (l1 != null || l2 != null) {
            int num1 = l1 != null ? l1.val : 0;
            int num2 = l2 != null ? l2.val : 0;
            int sum = carry + num1 + num2;
            carry = sum / 10;
            pre.next = new ListNode(sum % 10);
            pre = pre.next;
            if (l1 != null) {
                l1 = l1.next;
            }
            if (l2 != null) {
                l2 = l2.next;
            }
        }
        if (carry == 1) {
            pre.next = new ListNode(carry);
        }
        pre = node;
        return pre.next;
    }
}

解法二：递归解决链表问题（推荐）---使用递归解决遍历链表的场景真的太优雅了。

思路：主要就是将循环遍历的操作替换为递归遍历，其次是使用原链表存放新值，需要注意的就是需要保证存放新值的链表不为空。

代码如下：

// 递归链表
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 定义递归函数
        return addTwoNum(l1,l2,0);

    }

    private ListNode addTwoNum(ListNode l1, ListNode l2, int carry) {
        //定义边界 l1 l2 都为空表示遍历完成
        if (l1 == null && l2 == null) {
            return carry != 0 ? new ListNode(carry) : null;
        }
        int num1 = l1 != null ? l1.val : 0;
        int num2 = l2 != null ? l2.val : 0;
        int sum = carry + num1 + num2;
        carry = sum / 10;
        sum = sum % 10;
        if (l1 == null) {
            // 保证保存新值的连边是最长的。
            l1 = l2;
            l2 = null;
        }
        l1.val = sum;
        l1.next = addTwoNum(l1.next, l2 != null ? l2.next : null, carry);
        return l1;
    }