前言

处理链表有两种方式，第一，则是直接操作链表，适用于简单情况；第二，采用dummy做为新链表的头节点，把旧链表符合条件的节点以头插法/尾插法的方式接到dummy/dummy-tail后面。
除此之外，当给函数传入链表节点引用之和，当前函数的引用变量和调用函数的引用变量就是两个栈帧上的变量了，不是同一个了。

一、链表求和

二、dummy+尾插法

package everyday.medium;

// 链表求和
public class AddTwoNumbers {
    /*
    target：利用dummy,将生成的节点以尾插法的方式插入。
    链表求和的核心点：如果写函数处理剩余的长链表，则会出现尾插法tail指针不移动的情况，因为Java只有传值，两个tail已经是两个栈变量了。
     */
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 以dummy来作为新链表
        ListNode dummy = new ListNode(0);
        // 尾插法
        ListNode tail = dummy;
        // 进位
        int plus = 0;
        // 求和并进位
        while (l1 != null && l2 != null) {
            int sum = l1.val + l2.val + plus;
            int val = sum % 10;
            ListNode n = new ListNode(val);

            tail.next = n;
            tail = n;
            // for cycle
            l1 = l1.next;
            l2 = l2.next;
            plus = sum / 10;
        }
        // 处理不为空的长链表。
        processLongList(tail, l1 == null ? l2 : l1, plus);
        return dummy.next;
    }

    //
    private void processLongList(ListNode tail, ListNode l, int plus) {

        while (l != null) {
            int sum = l.val + plus;

            int val = sum % 10;
            ListNode n = new ListNode(val);

            tail.next = n;
            tail = n;

            l = l.next;
            plus = sum / 10;
        }
        // 顺便把plus 不为0的情况处理了，不然就需要把tail/plus都返回，注：这里的tail是传值，和上面函数那个tail已经是两个变量了。
        if (plus != 0) tail.next = new ListNode(plus);
    }

    // Definition for singly-linked list.
    public class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

总结

1）dummy+尾插法操作链表，统一操作。
2）给函数传入引用，则两个函数的引用就不同了，新函数的栈帧上分配了新的引用变量内存，用于指向堆地址。

参考文献

[1] LeetCode 链表求和