LeetCode 445. 两数相加 II（Java代码）

前往LeetCode 做题

题目描述

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

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

输入输出样例

示例：

输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 8 -> 0 -> 7

反转链表法

这道题目，将链表反转过来就和之前做过的两数相加是一样的了

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        l1 = reverse(l1);
        l2 = reverse(l2);
        ListNode dummyNode = new ListNode(0);
        ListNode curr = dummyNode;
        int carry = 0;

        while(l1 != null || l2 != null || carry == 1){
            int sum = carry;
            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 reverse(dummyNode.next);        
    }


    // 翻转单链表
    public ListNode reverse(ListNode node){
        ListNode prev = null;
        ListNode curr = node;
        while(curr != null){
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }
}

使用辅助栈

使用两个辅助栈

• 先遍历一遍，将节点的值分别存入两个栈中，这样出来的时候两个栈顶层的数位相同
• 将元素从栈中弹出，建立链表
  • 这里需要注意，由于我们使用了栈，其实就是相当于将链表反转了。
  • 如果再按照之前的做法，我们这样得到的链表也是反转后的
• 所以，需要使用头插法
  • 尾插法：每次新建立的节点，都是上一节点.next
  • 头插法：每次新建节点.next 都是上一节点

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<Integer> stack_l1 = new Stack<Integer>();
        Stack<Integer> stack_l2 = new Stack<Integer>();
        // 将元素遍历存入栈中
        while(l1 != null){
            stack_l1.push(l1.val);
            l1 = l1.next;
        }
        while(l2 != null){
            stack_l2.push(l2.val);
            l2 = l2.next;
        }

        ListNode curr = null;
        int carry = 0;

        while(!stack_l1.isEmpty() || !stack_l2.isEmpty() || carry == 1){
            int sum = carry;
            sum += (stack_l1.isEmpty()) ? 0 : stack_l1.pop();
            sum += (stack_l2.isEmpty()) ? 0 : stack_l2.pop();

			// 这里需要使用头插法，这样得到的链表和传入的数字是反向的
            ListNode node = new ListNode(sum % 10);
            node.next = curr;
            curr = node;

            carry = sum / 10;
        }

        return curr;        
    }
}

不使用任何的数据结构，也不改变链表结构的解法

这个方法，会在原先的链表上进行赋值

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 计算两个链表的长度差值
        int count = 0;
        for(ListNode runner = l1; runner != null; runner = runner.next){
            count++;
        }
        for(ListNode runner = l2; runner != null; runner = runner.next){
            count--;
        }
        // 说明 l2节点的长度长一些，交换两者，让 l1的长度始终最长
        if(count < 0){
            ListNode temp = l1;
            l1 = l2;
            l2 = temp;
        }
        // 新建一个节点，指向最长链表的第一个。 防止最长的节点需要进位
        ListNode head = new ListNode(0);
        head.next = l1;
        // 让长的链表先走，使两个链表的数位相同，同时存储从最高位起不为 9的第一个数位
        ListNode last = head;
        for(int i=0; i<Math.abs(count); i++){
            if(l1.val != 9){
                last = l1;
            }
            l1 = l1.next;
        }
        // 接下来，两个链表一起走
        while(l1 != null){
            int val = l1.val + l2.val;
            // 如果需要进位，就将所有last之后的都更新
            if(val > 9){
                val -= 10;
                last.val += 1;
                last = last.next;
                // 将last到l1之间的所有的9，都变成0
                while(last!=l1){
                    last.val = 0;
                    last = last.next;
                }
            }
            else if(val != 9){
                last = l1;
            }
            l1.val = val;
            l1 = l1.next;
            l2 = l2.next;
        }
        return (head.val == 0) ? head.next : head;
    }
}