給定兩個非空連結串列來表示兩個非負整數。位數按照逆序方式儲存，它們的每個節點只儲存單個數字。將兩數相加返回一個新的連結串列。

你可以假設除了數字 0 之外，這兩個數字都不會以零開頭。

示例：

輸入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出：7 -> 0 -> 8
原因：342 + 465 = 807

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int num = 0;
        ListNode proNode = new ListNode(0);
        ListNode currentNode = new ListNode(0);
        proNode.next = currentNode;
        do{
            int sum = (l1!=null?l1.val:0)+(l2!=null?l2.val:0)+num;
            num = sum/10;
            int result = sum%10;
            currentNode.val = result;
            l1 = l1!=null?l1.next:l1;
            l2 = l2!=null?l2.next:l2;
            if(l1!=null||l2!=null||num!=0){
                currentNode.next = new ListNode(0);
                currentNode = currentNode.next;
            }
        }while(l1!=null||l2!=null||num!=0);
        return proNode.next;
        
    }
}
 

/****************轉載*******************/

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

這道題是之前那道Add Two Numbers的拓展，我們可以看到這道題的最高位在連結串列首位置，如果我們給連結串列翻轉一下的話就跟之前的題目一樣了，這裡我們來看一些不修改連結串列順序的方法。由於加法需要從最低位開始運算，而最低位在連結串列末尾，連結串列只能從前往後遍歷，沒法取到前面的元素，那怎麼辦呢？我們可以利用棧來儲存所有的元素，然後利用棧的後進先出的特點就可以從後往前取數字了，我們首先遍歷兩個連結串列，將所有數字分別壓入兩個棧s1和s2中，我們建立一個值為0的res節點，然後開始迴圈，如果棧不為空，則將棧頂數字加入sum中，然後將res節點值賦為sum%10，然後新建一個進位節點head，賦值為sum/10，如果沒有進位，那麼就是0，然後我們head後面連上res，將res指向head，這樣迴圈退出後，我們只要看res的值是否為0，為0返回res->next，不為0則返回res即可，參見程式碼如下：

解法一：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int> s1, s2;
        while (l1) {
            s1.push(l1->val);
            l1 = l1->next;
        }
        while (l2) {
            s2.push(l2->val);
            l2 = l2->next;
        }
        int sum = 0;
        ListNode *res = new ListNode(0);
        while (!s1.empty() || !s2.empty()) {
            if (!s1.empty()) {sum += s1.top(); s1.pop();}
            if (!s2.empty()) {sum += s2.top(); s2.pop();}
            res->val = sum % 10;
            ListNode *head = new ListNode(sum / 10);
            head->next = res;
            res = head;
            sum /= 10;
        }
        return res->val == 0 ? res->next : res;
    }
};

下面這種方法使用遞迴來實現的，我們知道遞迴其實也是用棧來儲存每一個狀態，那麼也就可以實現從後往前取數字，我們首先統計出兩個連結串列長度，然後根據長度來呼叫遞迴函式，需要傳一個引數差值，遞迴函式引數中的l1連結串列長度長於l2，在遞迴函式中，我們建立一個節點res，如果差值不為0，節點值為l1的值，如果為0，那麼就是l1和l2的和，然後在根據差值分別呼叫遞迴函式求出節點post，然後要處理進位，如果post的值大於9，那麼對10取餘，且res的值自增1，然後把pos連到res後面，返回res，最後回到原函式中，我們仍要處理進位情況，參見程式碼如下：

解法二：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int n1 = getLength(l1), n2 = getLength(l2);
        ListNode *head = new ListNode(1);
        head->next = (n1 > n2) ? helper(l1, l2, n1 - n2) : helper(l2, l1, n2 - n1);
        if (head->next->val > 9) {
            head->next->val %= 10;
            return head;
        }
        return head->next;
    }
    int getLength(ListNode* head) {
        int cnt = 0;
        while (head) {
            ++cnt;
            head = head->next;
        }
        return cnt;
    }
    ListNode* helper(ListNode* l1, ListNode* l2, int diff) {
        if (!l1) return NULL;
        ListNode *res = (diff == 0) ? new ListNode(l1->val + l2->val) : new ListNode(l1->val);
        ListNode *post = (diff == 0) ? helper(l1->next, l2->next, 0) : helper(l1->next, l2, diff - 1);
        if (post && post->val > 9) {
            post->val %= 10;
            ++res->val;
        }
        res->next = post;
        return res;
    }
};

下面這種方法借鑑了Plus One Linked List中的解法三，在處理加1問題時，我們需要找出右起第一個不等於9的位置，然後此位置值自增1，之後的全部賦為0。這裡我們同樣要先算出兩個連結串列的長度，我們把其中較長的放在l1，然後我們算出兩個連結串列長度差diff。如果diff大於0，我們用l1的值新建節點，並連在cur節點後(cur節點初始化時指向dummy節點)。並且如果l1的值不等於9，那麼right節點也指向這個新建的節點，然後cur和l1都分別後移一位，diff自減1。當diff為0後，我們迴圈遍歷，將此時l1和l2的值加起來放入變數val中，如果val大於9，那麼val對10取餘，right節點自增1，將right後面節點全賦值為0。在cur節點後新建節點，節點值為更新後的val，如果val的值不等於9，那麼right節點也指向這個新建的節點，然後cur，l1和l2都分別後移一位。最後我們看dummy節點值若為1，返回dummy節點，如果是0，則返回dummy的下一個節點。

解法三：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int n1 = getLength(l1), n2 = getLength(l2), diff = abs(n1 - n2);
        if (n1 < n2) swap(l1, l2);
        ListNode *dummy = new ListNode(0), *cur = dummy, *right = cur;
        while (diff > 0) {
            cur->next = new ListNode(l1->val);
            if (l1->val != 9) right = cur->next;
            cur = cur->next;
            l1 = l1->next;
            --diff;
        }
        while (l1) {
            int val = l1->val + l2->val;
            if (val > 9) {
                val %= 10;
                ++right->val;
                while (right->next) {
                    right->next->val = 0;
                    right = right->next;
                }
                right = cur;
            }
            cur->next = new ListNode(val);
            if (val != 9) right = cur->next;
            cur = cur->next;
            l1 = l1->next;
            l2 = l2->next;
        }
        return (dummy->val == 1) ? dummy : dummy->next;
    }
    int getLength(ListNode* head) {
        int cnt = 0;
        while (head) {
            ++cnt;
            head = head->next;
        }
        return cnt;
    }
};