LeetCode02—两数相加（java版）

题目描述：

标签：递归    链表    数学

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

  代码：

一、方法一：非递归解法

思路分析：

①首先不处理进位。

创建一个新的链表，存储“和”。定义一个头结点head（用于处理进位时的遍历）和一个临时变量temp（用于求和时遍历链表l1,l2），把两个链表的对应结点值相加后存入temp.val，temp.next即temp移动分为以下四种情况。

  1.1 如果l1的下一个节点 和 l2的下一个节点 都为空，说明两个数字是等长的，同时两个链表都达到末尾，跳出循环。

  1.2 如果l1的下一个节点 为空，说明l2的长度大于l1，此时让temp.next指向l2剩下的链，跳出循环。

  1.3 如果l2的下一个节点 为空，说明l1的长度大于l2，此时让temp.next指向l1剩下的链，跳出循环。

  1.4 如果l1和l2的下一个节点 都不为空，则将l1 = l1.next,l2 = l2.next，此时让temp.next 指向新创建的结点（用于存储下一次求和的值），并移动temp = temp.next。

②接着处理进位的情况。

2.1 让temp指向头结点

2.2 从头结点开始遍历，当temp=null时跳出循环

    2.2.1 判断temp.val是否大于9

             => 如果大于9，则将temp.val%10取余，进位情况处理如下：

                     => 如果temp.next不为空，将temp.next.val+1。（主要是数字是0~9，两数相加最大为18，加上进位最大为19，不会超过20，所以进位就是加1）

                     => 如果temp.next为空，要创建新的结点存放进位1。

   2.2.2 temp = temp.next

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //题目说明是两个非空链表，所以不需要做链空判断
        ListNode head = new ListNode();//建立“和”链表的头结点
        ListNode temp = head;//定义一个临时变量
        //完成两条链表的相加
        while(true){
            temp.val = l1.val + l2.val;
            if(l1.next == null && l2.next == null){
                break;//如果两个链表都空了，就退出循环
            }else if(l1.next == null){
                temp.next = l2.next;//如果链表l1空了，就指向l2剩下的链
                break;
            }else if(l2.next == null){
                temp.next = l1.next;//如果链表l2空了，就指向l1剩下的链
                    break;
            }else{//都非空，移动l1,l2链表，建立新结点
                l1 = l1.next;
                l2 = l2.next;
                temp.next = new ListNode();
                temp = temp.next;
            }
        }
        temp = head;//在让临时变量回到“和”链表的头结点

        //完成链表每个节点只能存储一位数字的调整,对于大于等于10的结点进行进位处理
        while(temp != null){//遍历“和”链表
            if(temp.val > 9){
                temp.val = temp.val % 10;
                if(temp.next != null){//表明当前结点不是最后一个结点
                    temp.next.val += 1;
                }else{//表明当前结点是最后一个结点，需要添加结点存储进位
                    temp.next = new ListNode(1);
                    break;
                }    
            }
            temp = temp.next;
        } 

        return head;
    }
}

二、方法二：递归解法

思路分析：

①对链表l1和l2不等长的需要进行预处理。也就是因为要递归调用，所以很可能递归到某次一个链表已经遍历结束了，另一个链表还有剩余元素。所以要对遍历结束的链表新建“值为0，next为null"的结点来继续两结点相加运算。

②此处进位的处理是让链表的下个元素值直接+1。所以要先处理l1和l2都没有下一个结点的情况。如果两结点相加后值>9，则需要对值进行进位处理。

③ 对于②的其他情况就是：l1或者l2有一条链表不止有一个结点。如果两结点相加后值>9，则进行进位处理，如果l1有下一个结点，则让l1.next.val+1，否则让l2.next+1。处理进位后新建结点存储“和”以及next指向递归函数addTwoNumbers(l1.next,l2.next)。

总结：主要是对进位的处理。直接让下一个结点的值+1。但前提是要确保有下一个结点。同时面对不等长的情况，要记得补空。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //预处理，即将l1和l2链表的长度补齐
        if(l1 == null){
            l1 = new ListNode(0);
        }

        if(l2 == null){
            l2 = new ListNode(0);
        }

        if(l1.next == null && l2.next == null){//先分析两个链表只有1个结点的情况
            int val = l1.val + l2.val;
            if(val > 9){
                ListNode node = new ListNode(val%10);
                node.next = new ListNode(1);//进位
                return node;
            }else{
                return new ListNode(val);
            }
        }else{
            int val = l1.val + l2.val;
            if(val > 9){//对进位进行处理
                val = val % 10;
                if(l1.next != null){//如果l1的下一个节点非空则让它的值+1进位
                    l1.next.val += 1;
                }else if(l2.next != null){//如果l2的下一个节点非空则让它的值+1进位
                    l2.next.val += 1;
                }
            }
            ListNode node = new ListNode(val);
            node.next = addTwoNumbers(l1.next,l2.next);
            return node;
        }
    }

}