给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

开篇思路(半错误思路)：

以为把两个链表数相加，然后再一个个取出来放到链表里面就行了，没想到超int,long的范围…

思路：

首先判断两个链表哪个长，然后按照长的循环，短的循环完了以后就不用继续循环了
然后两个数相加容易进位(>=10)，所以next 用于存储进位数，然后sum用于统计两个链表数和next相加
然后就是取整，取余的过程，最后可能存在next进位，所以需要判断是否为0
最后再倒序存一遍就行了

初步结题：

/**
 * 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 len = 0, len2 = 0;
        ListNode nodes = null;
        ListNode t1 = l1,t2 = l2;
        //判断 哪个链表比较长
        while (t1 != null) {
            t1 = t1.next;
            len++;
        }
        while (t2 != null) {
            t2 = t2.next;
            len2++;
        }
        int next = 0;
        if (len >= len2){
            for (int i = 0 ; i < len ; i++){
                if (l2 != null){
                    int sum = l1.val + l2.val + next;
                    next = sum / 10;
                    int now = sum % 10;
                    nodes = addL(nodes,now);
                    l2 = l2.next ;
                } else {
                    int sum = l1.val + next;
                    next = sum / 10;
                    int now = sum % 10;
                    nodes = addL(nodes,now);
                }
                l1 = l1.next ;
            }
        }else {
            for (int i = 0 ; i < len2 ; i++){
                if (l1 != null ){
                    int sum = l1.val + l2.val + next;
                    next = sum / 10;
                    int now = sum % 10;
                    nodes = addL(nodes,now);
                    l1 = l1.next ;
                } else {
                    int sum = l2.val + next;
                    next = sum / 10;
                    int now = sum % 10;
                    nodes = addL(nodes,now);
                }
                l2 = l2.next ;
            }
        }
        //最后超范围 如果最后一位是9，需要进一位
        if (next != 0){
            nodes = addL(nodes,next);
        }
        //反着存一遍
        ListNode nodesLast = null;
        //判断 哪个链表比较长
        while (nodes != null) {
            nodesLast = addL(nodesLast,nodes.val);
            
            nodes = nodes.next;
        }
        return nodesLast;
    }

    private ListNode addL(ListNode next,int val){
        if (next == null) {
            next = new ListNode(val);
        } else {
            next = new ListNode(val, next);
        }
        return next;
    }
}

加深： 后续感觉遍历的时候可以优化循环判断,写那么多for循环重复代码太多

/**
 * 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 nodes = null;
        int tree = 0;
        while (l1 != null || l2 != null){
            int c1 = l1 != null ? l1.val : 0;
            int c2 = l2 != null ? l2.val : 0;
            int sum = c1 + c2 + tree;
            tree = sum / 10;
            int now = sum % 10;
            nodes = addL(nodes,now);
            l1 = l1 != null ? l1.next : null;
            l2 = l2 != null ? l2.next : null;
        }
        //最后超范围 如果最后一位是9，需要进一位
        if (tree != 0){
            nodes = addL(nodes,tree);
        }
        //反着存一遍
        ListNode nodesLast = null;
        //判断 哪个链表比较长
        while (nodes != null) {
            nodesLast = addL(nodesLast,nodes.val);
            nodes = nodes.next;
        }
        return nodesLast;
    }

    private ListNode addL(ListNode next,int val){
        if (next == null) {
            next = new ListNode(val);
        } else {
            next = new ListNode(val, next);
        }
        return next;
    }
}