题目：给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
Related Topics： 链表 数学

思路：既然要求是非空链表，那我们首先要创建一个链表ListNode；两个数相加，那其实就是写一个递归，递归最麻烦的是确定结束条件，和下一次递归的参数
结束条件：节点1+节点2=0；说明两个节点都是空节点；
节点1和节点2的下一节点都为null

1、构建链表节点

public class ListNode<T> {
    
    //节点包含的值
    private T value;
    
    //下一个节点指向
    private ListNode<T>  next;

    //初始化一个节点
    public ListNode(T value) {
        this.value = value;
    }

    //给节点添加下一个节点
    public void add(ListNode<T> newNode){
        if(this.next == null){
            this.next = newNode;
        }else {
            this.next.add(newNode);
        }

    }

    public static void main(String[] args) {
        ListNode listNode = new ListNode(0);
        listNode.add(new ListNode(0));
        listNode.add(new ListNode(0));
    }   
}

2、确定递归

2.1 实现一

把运算的值存储到一个空的节点l3中

public static void main(String[] args) {
        ListNode<Integer> l1 = new ListNode<Integer>(2);
        l1.add(new ListNode(4));
        l1.add(new ListNode(3));

        ListNode<Integer> l2 = new ListNode<Integer>(5);
        l2.add(new ListNode(6));
        l2.add(new ListNode(4));

        ListNode l3 = new ListNode(0);
        addTwoNumbers1(l1, l2, l3);
        System.out.println("===");

    }

    private static ListNode<Integer> addTwoNumbers1(ListNode<Integer> l1, ListNode<Integer> l2, ListNode<Integer> l3) {
        Integer v1 = l1==null?0:l1.getValue();
        Integer v2 = l2==null?0:l2.getValue();
        Integer v3 = l3==null?0:l3.getValue();
        int temp =  v1 + v2 + v3;
        if(temp >= 10){
            l3.setValue(temp % 10);
            l3.add(new ListNode(temp /10));
        }else if(temp < 10) {
            l3.setValue(temp);
            if((null == l1||null==l1.getNext()) && (null ==l2|| null==l2.getNext())){
                return l3;
            }
            l3.add(new ListNode(0));
        }if (temp == 0){
            return l3;
        }

        return addTwoNumbers1(l1==null?null:l1.getNext(),l2==null?null:l2.getNext(),l3.getNext());
    }   
}

2.2 实现二

把运算的值存储到已有的节点l1中

public class addTwoNumbers {

    public static void main(String[] args) {

        ListNode<Integer> l1 = new ListNode<Integer>(2);
        l1.add(new ListNode(4));
        l1.add(new ListNode(3));


        ListNode<Integer> l2 = new ListNode<Integer>(5);
        l2.add(new ListNode(6));
        l2.add(new ListNode(4));

        addTwoNumbers2(l1, l2);
        System.out.println("===");

    }

    private static ListNode<Integer> addTwoNumbers2(ListNode<Integer> l1, ListNode<Integer> l2) {
        //先判断当前节点是否为null
        Integer v1 = l1==null?0:l1.getValue();
        Integer v2 = l2==null?0:l2.getValue();

        int temp =  v1 + v2 ;

        //累加大于10的话，需要进位
        if(temp >= 10){
            l1.setValue(temp%10);

            //累加运算的结果是要更新在l1的相应位置，所以进位需要判断next是否为null
            ListNode<Integer> next = l1.getNext();
            if(null == next){
                l1.add(new ListNode<>(1));
            }else {
                next.setValue(next.getValue() + 1);
            }
        }if (temp == 0){
            //等于0的话，说明当前节点都是null，退出递归
            return l1;
        } else if(temp < 10) {
            //小于10的话，不需要进位
            l1.setValue(temp);
            //但是需要判断当前节点的下一节点是否为null，如果是退出递归
            if((null == l1||null==l1.getNext()) && (null ==l2|| null==l2.getNext())){
                return l1;
            }
            //累加运算的结果是要更新在l1的相应位置，所以需要判断l1.next是否为null
            //如果是的话，需要先添加一个空节点，让其存储下一轮递归的值
            if(null == l1.getNext()) {
                l1.add(new ListNode(0));
            }
        }

        return addTwoNumbers2(l1==null?null:l1.getNext(),l2==null?null:l2.getNext());
    }
}