LeetCode 算法之旅 | 2. 两数相加

题目描述

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

—— 原文摘自：力扣(LeetCode) | https://leetcode-cn.com/problems/add-two-numbers

题解记录

看完这道题的第一感觉是我之前做过！但是呢，之前是用 Python 写的，而且主要目的是用来熟悉 Python 语法的，根本没有用算法去实现，因此看到这道题的第一时间，我就排除掉了将其转换成整数相加后再转回来的想法，因为实在是太蠢了(之前这样做过😂)。

解法一：逐位相加(加法竖式)

由于原题给出的链表是逆序的，而且是单向的，因此刚好符合我们加法竖式的思想，从低位往高位逐位相加，大于 10 就进位！同时，原题中提到 每个节点只能存储 一位 数字，因此某一位上两个数字相加的结果最大为 9 + 9 + 1 = 19 ，因此还算比较简单。一下也考虑不全面，所以我的做法是边写边完善。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int carry = 0;
        ListNode result = new ListNode(0);
        ListNode tmp = result;
        while(l1 != null || l2 != null || carry > 0) {
            int l1Val = l1 == null ? 0 : l1.val;
            int l2Val = l2 == null ? 0 : l2.val;
            int sum = l1Val + l2Val + carry;
            carry = sum / 10;
            ListNode node = new ListNode(sum % 10);
            tmp.next = node;
            tmp = node;
            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        return result.next;
    }
}

我刚开始写出来的答案是这样的，而且想了半天也没有想出来有其他的解法，于是，就看了看大佬们的解法。果然，在一番瞻仰之后，我将答案稍作了改善。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int carry = 0;
        ListNode result = new ListNode(0);
        ListNode tmp = result;
        while(l1 != null || l2 != null || carry > 0) {
            if(l1 != null) {
                carry += l1.val;
                l1 = l1.next;
            }
            if(l2 != null) {
                carry += l2.val;
                l2 = l2.next;
            }
            tmp.next = new ListNode(carry % 10);
            tmp = tmp.next;
            carry /= 10;
        }
        return result.next;
    }
}

可以看到，比之前的第一版是简化了一些的，但是其主要的算法思想并没有发生变化。

具体的思路可以参考以下链接：

• 官方题解 | 两数相加
• 图解 | 两数相加

但官方和这个图解，包括我最开始的思路，以及评论区的很多人的写法都是使用了哑结点(官方说叫这个，我也不知道😂)，那么，真的必须这样写吗？我试了下。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(0);
        ListNode cursor = result;
        int carry = 0;
        while(l1 != null || l2 != null || carry > 0) {
            if(l1 != null) {
                carry += l1.val;
                l1 = l1.next;
            }
            if(l2 != null) {
                carry += l2.val;
                l2 = l2.next;
            }
            cursor.val = carry % 10;
            carry = carry / 10;
            cursor.next = (l1 == null && l2 == null && carry == 0) ? null : new ListNode(0);
            cursor = cursor.next;
        }
        return result;
    }
}

真的让我找出解决方案了，但是在最后的末尾节点处需要一个额外的判断，而且似乎性能不太好，运行了3ms(其他都是2ms)，但是最起码证明了这种方法是可以的。

解法二：递归实现

说实话，我还是看了大佬们的题解以及评论区大佬们的评论后才发现还可以这样做的。话不多说，来看下代码。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        return add(l1, l2, 0);
    }

    public ListNode add(ListNode l1, ListNode l2, int carry) {
    	// 递归的终止条件是 l1 和 l2 都为空
		// 如果 carry > 0 需要返回一个进位标志
        if(l1 == null && l2 == null) {
            return carry > 0 ? new ListNode(carry) : null;
        }
        // 如果 l1 为空则将 ListNode(0) 赋给 l1，对于 l2 也是
        // 为了确保最终返回的结果链表中每一个节点都是有意义的节点，而不是 null
        l1 = l1 == null ? new ListNode(0) : l1;
        l2 = l2 == null ? new ListNode(0) : l2;
        // l1位 + l2位 + 进位
        int sum = l1.val + l2.val + carry;
        // 当前节点的值
        l1.val = sum % 10;
        // 对结果链的下一个节点进行递归计算
        l1.next = add(l1.next, l2.next, sum / 10);
        return l1;
    }
}

运算过程参考下图：

具体思路可参考：动画演示 2. 两数相加

官方题解中给出了一个拓展题：正序两数相加

对于这个拓展，我本来还想到的是可以继续按照逐位相加的思路去运算，每次 当前位(进位) ⇒ 上一位 时直接改动上一位的值，但是，我忽略了 当前位(进位) ⇒ 上一位(被迫再次进位) ⇒ 上上一位 ⇒ ... 这种情况，而且题中的链表是单向链表，这样很难实现。
于是，我又想到采用一个 flag list 来标记需要进位的位，但动态数组得用 List ，并且链表无法直接 get 节点，复杂度直线上升。
所以，我觉得还是采用大佬们的解法比较好😂。
正序 - 两数相加

参考资料

• 官方题解 | 两数相加
• 图解 | 两数相加
• 动画演示 2. 两数相加
• 正序 - 两数相加