剑指LeetCode 面试题 02.05. 链表求和（medium）

前往 LeetCode 做题

题目

给定两个用链表表示的整数，每个节点包含一个数位。

这些数位是反向存放的，也就是个位排在链表首部。

编写函数对这两个整数求和，并用链表形式返回结果。

示例：

输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
输出：2 -> 1 -> 9，即912

非递归解法（推荐）

步骤

• 使用 dummyHead（哑节点）和 curr（工作节点）

• while循环的选择

• 每一次迭代都建立一个新的节点

代码：

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 哑节点
        ListNode dummyHead = new ListNode(0);
        // 工作节点
        ListNode curr = dummyHead;
        // 进位量
        int carry = 0;
        
        //对于迭代而言，while循环的选择条件非常重要
        while(l1 != null || l2 != null || carry != 0){
            // 只要上述的三个条件一个满足，就可以继续进行循环下去

            // 计算当前的和
            int sum = carry;
            // 由于l1和l2都有可能是为空的，所以这一步（关键）
            sum += (l1==null) ? 0 : l1.val;
            sum += (l2==null) ? 0 : l2.val;

            // 建立新的指针
            curr.next = new ListNode(sum%10);
            curr = curr.next;
            
            // 进行下一次迭代的时候变量的更新
            carry = sum/10;
            if(l1!=null) l1=l1.next;
            if(l2!=null) l2=l2.next;
        }
        return dummyHead.next;
    }
}

复杂度分析：

• 时间复杂度 O(M+N)：需要遍历一遍两个链表
• 空间复杂度 O(1)：只需要常量级的空间

参考自 VaporMax

while条件选的好，iterate迭代解得快

递归法

使用递归来做：

• 输入值：两个链表的节点
• 递归返回条件：其中一个链表为空（可能存在 null 9 然后还要进一位）
• 操作：新建一个节点，将两个链表相加的值存入节点。
  • 如果要进位的话，往递归中传入参数
• 返回值：返回递归的结果

代码

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 一开始不用进位+1，所以传入0
        return addTwoNumbers(l1, l2, 0);
    }

    // 重构函数，添加是否需要进位，如果需要进位addNum=1，否则addNum=0
    public ListNode addTwoNumbers(ListNode l1, ListNode l2, int addNum){
        // 递归的返回条件：其中一个链表为空
        if(l1 == null){
            return helper(l2, addNum);
        }
        if(l2 == null){
            return helper(l1, addNum);
        }

        // 操作：新建一个节点，将两个节点的值和 addNum 相加
        int sum = l1.val + l2.val + addNum;
        // 新建一个节点
        ListNode node = new ListNode(sum%10);
        // 承接子递归的返回值
        node.next = addTwoNumbers(l1.next, l2.next, sum/10);

        // 返回值：node
        return node;
    }
    
    // 如果另一条链表为空的时候，将需要进位的步骤走完
    public ListNode helper(ListNode l, int addNum){
        // 如果不需要进位，直接返回该链表即可
        if(addNum == 0) return l;
        // 如果这一条链表也是空的，但是又需要进位的话，就新建一个节点并返回
        if(l == null){
            return new ListNode(1);
        }
        // 如果上面两个条件都不满足的话，等价于 l != null && addNum == 1
        ListNode curr = l;
        // 只要curr.val等于9，说明下一位需要进位
        while(curr!=null && curr.val == 9){
			// 当前节点 9+1 = 10，进位，当前节点变为0
            curr.val = 0;
            // 如果当前节点的下一个节点是空的话，但是要进位，所以就新建一个节点
            if(curr.next == null) curr.next = new ListNode(0);
            curr = curr.next;
        }
        // 循环条件选的好，判断结果超方便
        if(curr!=null) curr.val += addNum;
        return l;
    }
}

复杂度分析：

• 时间复杂度 O(M+N)：需要遍历一遍两个链表
• 空间复杂度 O(min(M+N))：递归的时候需要栈，当其中一个链表为空的时候，不再递归。

奇妙的递归解法

思路：
如果两个链表一长一短。那么递归的时候，就把两个链表补齐到一样的长度

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        return sum(l1,l2,0);
    }

    ListNode sum(ListNode s1, ListNode s2, int buy) {
        int currentLevelSum = s1.val + s2.val + buy;
        ListNode currentNode = new ListNode(currentLevelSum % 10);
        
        // 如果两个链表的下一个都是空的了，看看要不要进位，然后返回结果即可
        if (s1.next == null && s2.next == null) {
            if (currentLevelSum / 10 != 0) {
                currentLevelSum = currentLevelSum/10;
                currentNode.next = new ListNode(currentLevelSum);
            }
            return currentNode;
        }
        
        // 如果其中一个链表空了，就新建一个指针补齐它
        s1 = s1.next != null ? s1.next : new ListNode(0);
        s2 = s2.next != null ? s2.next : new ListNode(0);

        currentNode.next = sum(s1, s2, currentLevelSum / 10);
        return currentNode;
    }
}

复杂度分析：

• 时间复杂度 O(max(M,N)*2)：由于是将两个链表补到一样的长度，所以遍历的次数要多些。
• 空间复杂度 O(max(M,N))：递归的时候会递归到最长的那个节点的末尾。