Leetcode-2. 两数相加逆序相加

2. 两数相加

题目：

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

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

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

示例：

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

解答：以最长的那条链表作为基础，进行两条链表的遍历，当一条链表的节点非空，另一条为空的时候，为空的就取值为0，比如243 和240代表342+42。然后再遍历的时候，加上来自上一次节点相加的进位数进行判断，因为每位数的结果=来自两个节点数的和+上一次的进位数，存%10，/10为进位数（0不进位，1 >0进位）

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

• 有进位，但是结果位数和最长的一样

342+455=797
输入：(2 -> 4 -> 3) + (5 ->5 -> 4)
输出：7 -> 9-> 7

• 无进位，按位相加即可

555+455=1010
输入：(5 -> 5 -> 5) + (5 -> 5 -> 4)
输出：0 ->1-> 0 -> 1

• 有进位，结果位数比最长的多一位

999+9=1008
输入：(9 -> 9-> 9) + (9)
(9 -> 9-> 9) + (9-> 0-> 0)
输出：8 ->0-> 0 -> 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) {
        int num = 0;
        ListNode l3 = new ListNode();
        ListNode temp = l3;
        Boolean flag;
        while (l1 != null || l2 != null) {
            flag=false;
            int n1 = 0, n2 = 0;
            if (l1 != null) {
                n1 = l1.val;
                l1=l1.next;
                if(l1!=null)
                {flag=true;}
            }
            if (l2 != null) {
                n2 = l2.val;
                l2=l2.next;
                if(l2!=null)
                {flag=true;}
            }
            temp.val=(num + n1 + n2) % 10;
            num = (num + n1 + n2) / 10;
            if (flag||num>0) {
                temp.next = new ListNode();
            }
            temp=temp.next;
        }
        if(num>0){
            temp.val=num;
        }
        return l3;
    }
}

首先定义 一个节点3(头节点)，进位num初始化为0，辅助节点temp,以及新否为链表3创建新节点的标志flag
执行条件：节点1，2其中有一个非空，则可以进行相加。

1. 初始化 flag=f，初始化来自节点1，2的取值 n1=0，n2=0

2. 每遍历一次，判断当前节点（1/2）是否为空，不为空则从节点取值，同时指向下一个节点，并改变标志flag；若节点为空则为原本初始化时候的0；(避免了创建新节点存0的情况，用了类似双指针的思路)

3. 将来自上一次的进数与当前两个取值进行计算；
   –> temp.val=(num + n1 + n2) % 10;
   –> num = (num + n1 + n2) / 10; 下一个进位数

4. 判断 标志flag以及num（当节点1，2发生指向下节点时候，必然和的结果也在改变，需要在原基础上新建一个节点；同时，节点1，2都是非空，都是同样同样长度下结尾的数时候，当进位数>0，就需要在结果上多创建一个节点）但是对于这两种情况，有不一样就是当为遍历完的时候，只是新建一个节点，赋值在下一次的相加；而第二种情况是在遍历完的情况下，超过最长链表长度的情况下，对进位数的判断进行是否新建节点，他的赋值将在遍历结束在处理）

5. 继续 步骤1

6. 待遍历完链表，对最后的节点进行赋值判断，判断sum，>0说明最后一位是进位，否则就不是进位得来的，在遍历过程就已经赋过值了

7. 最后输出头节点（一开始创建的是头节点，输出是头节点，但是处理的过程是对辅助节点进行处理，在想这里的时候花了点时间）