LeetCode 445. Add Two Numbers II

You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Follow up:
What if you cannot modify the input lists? In other words, reversing the lists is not allowed.

Example:

Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 8 -> 0 -> 7

输入为2个用链表表示的整数，求2个整数的和，输出依然是链表形式。

坑：不要直接计算2个整数的和，因为可能会产生整数溢出。不管怎么实现，核心是逐位进行加法运算，考虑进位的问题。

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null && l2 == null) {
            return null;
        }
        if(l1 != null && l2 == null) {
            return l1;
        }
        if(l1 == null && l2 != null) {
            return l2;
        }
        Stack<Integer> s1 = getValStack(l1);
        Stack<Integer> s2 = getValStack(l2);
        Stack<Integer> result =  new Stack<>();;
        getResultStack(s1, s2, result);
        return transfer(result);
    }

    private void getResultStack(Stack<Integer> s1, Stack<Integer> s2, Stack<Integer> result) {
        int sum;
        int carry = 0;
        while (s1.size() > 0 && s2.size() > 0){
            sum = s1.pop() + s2.pop() + carry;
            if(sum >= 10) {
                sum = sum % 10;
                carry = 1;
            } else {
                carry = 0;
            }
            result.add(sum);
        }
        if(s1.size() == 0 && s2.size() == 0) {
            if(carry == 1) {
                result.add(1);
            }
            return ;
        }
        if(s1.size() > 0 && s2.size() == 0) {
            if(carry == 1) {
                Stack<Integer> tempStack = new Stack<>();
                tempStack.add(1);
                 getResultStack(s1, tempStack, result);
            } else {
                Collections.reverse(s1);
                result.addAll(s1);
                return ;
            }
        }
        if(s1.size() == 0 && s2.size() > 0) {
            if(carry == 1) {
                Stack<Integer> tempStack = new Stack<>();
                tempStack.add(1);
                 getResultStack(s2, tempStack, result);
            } else {
                Collections.reverse(s2);
                result.addAll(s2);
                return ;
            }
        }
        return ;
    }

    private Stack<Integer> getValStack(ListNode list) {
        Stack<Integer> result = new Stack<>();
        while(list != null) {
            result.add(list.val);
            list = list.next;
        }
        return result;
    }

    private ListNode transfer(Stack<Integer> stack) {
        if(stack == null || stack.size() == 0) {
            return null;
        }

        ListNode head = null;
        ListNode tail = null;
        while(stack.size() > 0) {
            ListNode node = new ListNode(stack.pop());
            if(head == null) {
                head = tail = node;
            } else {
                tail = tail.next = node;
            }
        }
        return head;
    }

}