Add Two Numbers I & II

Add Two Numbers I

You have two numbers represented by a linked list, where each node contains a single digit. The digits are stored in reverse order, such that the 1's digit is at the head of the list. Write a function that adds the two numbers and returns the sum as a linked list.

Example

Given 7->1->6 + 5->9->2. That is, 617 + 295.

Return 2->1->9. That is 912.

Given 3->1->5 and 5->9->2, return 8->0->8.

 /**
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
         if (l1 == null) return l2;
         if (l2 == null) return l1;

         int value1 = , value2 = , carry = , sum = ;
         ListNode head = new ListNode();
         ListNode current = head;

         while (l1 != null || l2 != null || carry == ) {
             value1 = (l1 == null ?  : l1.val);
             value2 = (l2 == null ?  : l2.val);
             sum = value1 + value2 + carry;

             current.next = new ListNode(sum % );
             current = current.next;

             carry = sum / ;
             l1 = (l1 == null) ? null : l1.next;
             l2 = (l2 == null) ? null : l2.next;
         }
         return head.next;
     }
 }

Add Two Numbers II

You are given two linked lists representing two non-negative numbers. 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

分析: reverse 之后再相加，然后再reverse result linkedlist

 /**
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
         if (l1 == null) return l2;
         if (l2 == null) return l1;

         l1 = reverse(l1);
         l2 = reverse(l2);

         return reverse(helper(l1, l2));
     }

     public ListNode reverse(ListNode head) {
         if (head == null || head.next == null) return head;

         ListNode pre = null;
         ListNode current = head;
         ListNode next = null;

         while (current != null) {
             next = current.next;
             current.next = pre;
             pre = current;
             current = next;
         }
         return pre;
     }

     public ListNode helper(ListNode l1, ListNode l2) {
         if (l1 == null) return l2;
         if (l2 == null) return l1;

         int value1 = , value2 = , carry = , sum = ;
         ListNode head = new ListNode();
         ListNode current = head;

         while (l1 != null || l2 != null || carry == ) {
             value1 = (l1 == null ?  : l1.val);
             value2 = (l2 == null ?  : l2.val);
             sum = value1 + value2 + carry;

             current.next = new ListNode(sum % );
             current = current.next;

             carry = sum / ;
             l1 = (l1 == null) ? null : l1.next;
             l2 = (l2 == null) ? null : l2.next;
         }
         return head.next;
     }
 }

方法二：用stack存list中的值，这样从上到下就是位数从小到大。

 public class Solution {
   public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
     Stack<Integer> s1 = new Stack<>();
     Stack<Integer> s2 = new Stack<>();

     while (l1 != null) {
       s1.push(l1.val);
       l1 = l1.next;
     }

     while (l2 != null) {
       s2.push(l2.val);
       l2 = l2.next;
     }
     int carry = ;
     ListNode head = new ListNode();
     while (!s1.empty() || !s2.empty() || carry != ) {
       int sum = ;
       if (!s1.empty()) {
         sum += s1.pop();
       }
       if (!s2.empty()) {
         sum += s2.pop();
       }
       sum += carry;
       carry = sum / ;
       ListNode node = new ListNode(sum % );
       node.next = head.next;
       head.next = node;
     }
     return head.next;
   }
 }