Java——LeetCode02： 两数相加

题目：

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

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

示例：

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

题解代码：

/**
 * 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){
        if(l1 == null && l2 == null) return null;
         /*创建一个pre链表用来标记数位，
           这个pre链表头节点的值可以是任意的，因为计算后的值就是pre头结点的下一个节点的值
           令头结点的值为0
           然后我们以题目为例：(2 -> 4 -> 3) + (5 -> 6 -> 4)
           第一次相加是个位相加，对应的个位相加就是 2+5 = 7
           那么：第一次相加后链表per变为：0 -> 7
           当对应的个位、十位、百位加完后
           链表per变为：0 -> 7 -> 0 -> 7+1
         */
        ListNode pre = new ListNode(0);
        ListNode curr = pre;//创建curr用来遍历链表
        int addOne = 0;//判断对应位数是否相加是否大于9，大于9则进位
        while (l1 != null || l2 != null || addOne > 0){
            int sum = addOne;//让sum先等于0
            sum += l1 == null ? 0 : l1.val;//如果l1不为空则让sum加对应节点的值
            sum += l2 == null ? 0 : l2.val;//同理

            addOne = sum > 9 ? 1 : 0 ;//如果sum>9,进位
            curr.next = new ListNode(sum % 10);//取sum的个位，并存入curr.next
            curr = curr.next;//遍历下一个结点

            if (l1 != null)//判断l1是否为空
                l1 = l1.next;
            if (l2 != null)//判断l1是否为空
                l2 = l2.next;
        }
    /*  curr开始指向了pre，也就是新的链表的头，
        curr是不断移动的，到了最后，curr指向的是新链表的尾，
        返回curr只能返回尾部结点的值，那就是NULL
        而while循环结束后，链表pre变为：0 -> 7 -> 0 -> 8
        而返回pre.next也就是返回了pre链表的第二个结点7
        从而可以用循环遍历结点7后面的所有结点
    */
        return pre.next;//返回per.next，就是返回结点7
    }

测试代码：

public class Code02AddTwoNumbers {

    public static void main(String[] args) {

        ListNode l1 = new ListNode(2);
        l1.next = new ListNode(4);
        l1.next.next = new ListNode(3);
        ListNode l2 = new ListNode(5);
        l2.next = new ListNode(6);
        l2.next.next = new ListNode(4);
        System.out.println(printListNode(new Solution().addTwoNumbers(l1, l2)).toString());

        ListNode l3 = createNode(2, 4, 5, 1);
        ListNode l4 = createNode(5, 6, 4);
        System.out.println(printListNode(new Solution().addTwoNumbers(l3, l4)).toString());
    }
    public static ListNode createNode(int ... x){
        ListNode l = new ListNode(0);
        ListNode node = l;
        if(x.length > 0 ) {
            for (int i : x) {
                node.next = new ListNode(i);
                node = node.next;
            }
            return l.next;
        }
        else return null;
    }
    //打印链表
    public static StringBuilder printListNode(ListNode l){
        StringBuilder stringBuilder = new StringBuilder();
        while (l != null){
            stringBuilder.append(l.val);
            l = l.next;
        }
        return stringBuilder;
    }
}

class ListNode {
    int val;
     ListNode next;
     ListNode(int x) { val = x; }
 }
/**
 * 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){
        if(l1 == null && l2 == null) return null;
         /*创建一个pre链表用来标记数位，
           这个pre链表头节点的值可以是任意的，因为计算后的值就是pre头结点的下一个节点的值
           令头结点的值为0
           然后我们以题目为例：(2 -> 4 -> 3) + (5 -> 6 -> 4)
           第一次相加是个位相加，对应的个位相加就是 2+5 = 7
           那么：第一次相加后链表per变为：0 -> 7
           当对应的个位、十位、百位加完后
           链表per变为：0 -> 7 -> 0 -> 7+1
         */
        ListNode pre = new ListNode(0);
        ListNode curr = pre;//创建curr用来遍历链表
        int addOne = 0;//判断对应位数是否相加是否大于9，大于9则进位
        while (l1 != null || l2 != null || addOne > 0){
            int sum = addOne;//让sum先等于0
            sum += l1 == null ? 0 : l1.val;//如果l1不为空则让sum加对应节点的值
            sum += l2 == null ? 0 : l2.val;//同理

            addOne = sum > 9 ? 1 : 0 ;//如果sum>9,进位
            curr.next = new ListNode(sum % 10);//取sum的个位，并存入curr.next
            curr = curr.next;//遍历下一个结点

            if (l1 != null)//判断l1是否为空
                l1 = l1.next;
            if (l2 != null)//判断l1是否为空
                l2 = l2.next;
        }
    /*  curr开始指向了pre，也就是新的链表的头，
        curr是不断移动的，到了最后，curr指向的是新链表的尾，
        返回curr只能返回尾部结点的值，那就是NULL
        而while循环结束后，链表pre变为：0 -> 7 -> 0 -> 8
        而返回pre.next也就是返回了pre链表的第二个结点7
        从而可以用循环遍历结点7后面的所有结点
    */
        return pre.next;//返回per.next，就是返回结点7
    }
}

输出结果：