链表--两个链表相加

问题：
假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
给定两个这种链表，请生成代表两个整数相加值的结果链表。

数据范围：10000000≤n,m≤1000000，链表任意值 0≤val≤9

要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

看到这道题有两个思路：

第一个思路，通过字符串解答，将链表的值通过字符串拼接起来，然后通过Long封装类进行转换，然后相加求和，最后在通过头插法建立链表。
但是，在测试的链表长度太长时显然就不能通过测试，long总是有范围的，所以有了第二次优化。

第二个思路：通过题意可知，我们要从尾部求和开始，这时候就想到了栈，首先经过两次循环将链表放入栈内，然后从尾部开始进行加和，然后通过头插法建立链表，因为每个值都是0~9的范围，不会出现超出范围的值。

注意的点：注意最后一次的循环的进位，如果进位是0 就结束循环，如果是1，则需要继续进行一次循环。

import java.lang.*;

public class Solution {
    
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
//         String s="";
//         while (head1!=null){
//             s+=head1.val;
//             head1=head1.next;
//         }
//         String h="";
//         while (head2!=null){
//             h+=head2.val;
//             head2=head2.next;
//         }
//         long sum=Long.parseLong(s)+Long.parseLong(h);
//         String f=sum+"";
//         ListNode node=new ListNode(-1);
//         ListNode head=node;
//         for (int i=0;ia1=new Stack<>();
        Stacka2=new Stack<>();
        int b1=0;
        while (head1!=null){
            a1.push(head1);
            head1=head1.next;
            b1++;
        }
        int b2=0;
        while (head2!=null){
            a2.push(head2);
            head2=head2.next;
            b2++;
        }
        int jia=0;
        int max=Math.max(b1,b2);
        ListNode node=new ListNode(-1);
        ListNode g=node;
        ListNode head=node;
        while (max!=0){
            int sum=0;
            if (!a1.empty()){
                sum+=a1.pop().val;
            }
            if (!a2.empty()){
                sum+=a2.pop().val;
            }
            if(jia==1){
                sum+=jia;
                jia=0;
            }
            if (sum>=10){
                sum=sum%10;
                jia=1;
            }
            ListNode listNode=new ListNode(sum);
            listNode.next=node.next;
            node.next=listNode;
            max--;
            if(max==0&&jia==1){
                max++;
            }
        }
        return head.next;
    }
}