Add Two Numbers

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

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

/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/

public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = new ListNode(-1);
        ListNode p = head;
        int carry = 0;
        while(l1 != null || l2 != null){
            int result = 0;
            int va = (l1 == null)? 0: l1.val;
            int vb = (l2 == null)? 0: l2.val;
            result = (va+vb+carry)%10;
            carry = (va+vb+carry)/10;
            p.next = new ListNode(result);
            p = p.next;
            l1 = (l1 == null ? null : l1.next);
            l2 = (l2 == null ? null : l2.next);
        }
        
        if(carry != 0){
            p.next = new ListNode(carry);
        }
        
        return head.next;
    }
}

stack 解法，不 reverse list

public static ListNode addTwoNumber(ListNode l1, ListNode l2){
        Stack<Integer> s1 = new Stack<Integer>();
        Stack<Integer> s2 = new Stack<Integer>();        
        
        ListNode fake = new ListNode(Integer.MIN_VALUE);
        
        ListNode runner = l1;
        while(runner != null){
            s1.push(runner.val);
            runner = runner.next;
        }
        
        runner = l2;
        while(runner != null){
            s2.push(runner.val);
            runner = runner.next;
        }
        
        runner = fake;
        int carry = 0;
        while(!s1.empty() || !s2.empty()){
            int v1 = (s1.empty()? 0: s1.pop());
            int v2 = (s2.empty()? 0: s2.pop());
            int d = v1+v2+carry;
            carry = d/10;
            runner.next = new ListNode(d%10);
            runner =runner.next;
        }
        
        if(carry != 0){
            runner.next = new ListNode(carry);
        }
        
        // reverse the result list
        ListNode head = fake.next;
        fake.next = null;
        ListNode slow = head, fast = head.next, tmp = null;
        while(fast != null){
            tmp = fast.next;
            fast.next = slow;
            slow = fast;
            fast = tmp;
        }
        head.next = null;
        
        
        return slow;
    }