leetcode兩數相加問題及其拓展問題解決

給出兩個 非空 的鏈表用來表示兩個非負的整數。其中，它們各自的位數是按照 逆序 的方式存儲的，而且它們的每一個節點只能存儲 一位 數字。

若是，咱們將這兩個數相加起來，則會返回一個新的鏈表來表示它們的和。

您能夠假設除了數字 0 以外，這兩個數都不會以 0 開頭。

示例：

輸入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出：7 -> 0 -> 8
緣由：342 + 465 = 807複製代碼

僞代碼以下：

• 將當前結點初始化爲返回列表的啞結點。
• 將進位carry初始化爲0。
• 將p和q分別初始化爲列表l1 和l2 的頭部。
• 遍歷列表l1 和l2 直至到達它們的尾端。
  • 將x 設爲結點p 的值。若是p 已經到達l1 的末尾，則將其值設置爲0
    
  • 將y 設爲結點q 的值。若是q 已經到達l2 的末尾，則將其值設置爲0
    
  • 設定sum = x + y + carry。
  • 更新進位的值，carry=sum/10。
  • 建立一個數值爲(sum mod 10)的新結點，並將其設置爲當前結點的下一個結點，而後將當前結點前進到下一個結點。
  • 同時，將p 和q 前進到下一個結點。
• 檢查carry=1 是否成立，若是成立，則向返回列表追加一個含有數字1 的新結點。
• 返回啞結點的下一個結點。

請注意，咱們使用啞結點來簡化代碼。若是沒有啞結點，則必須編寫額外的條件語句來初始化表頭的值。

請特別注意如下狀況：

測試用例	說明
l1=[0,1] l1=[0,1] l2=[0,1,2] l2=[0,1,2]	當一個列表比另外一個列表長時。
l1=[] l1=[] l2=[0,1] l2=[0,1]	當一個列表爲空時，即出現空列表。
l1=[9,9] l1=[9,9] l2=[1] l2=[1]	求和運算最後可能出現額外的進位，這一點很容易被遺忘

複雜度分析

• 時間複雜度：O(max(m,n))，假設m 和n 分別表示l1 和l2 的長度，上面的算法最多重複max(m,n) 次。

• 空間複雜度：O(max(m,n))， 新列表的長度最多爲max(m,n)+1。

拓展

若是鏈表中的數字不是按逆序存儲的呢？例如：

(3 \to 4 \to 2) + (4 \to 6 \to 5) = 8 \to 0 \to 7

(3→4→2)+(4→6→5)=8→0→7

這種狀況下：

解法一：

咱們能夠利用棧來保存全部的元素，而後利用棧的後進先出的特色就能夠從後往前取數字了，咱們首先遍歷兩個鏈表，將全部數字分別壓入兩個棧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;
    }
};
複製代碼

解法三：

先算出兩個鏈表的長度，咱們把其中較長的放在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;
    }
};複製代碼

參考資料：

discuss.leetcode.com/topic/67076…

discuss.leetcode.com/topic/65279…

discuss.leetcode.com/topic/65306…

discuss.leetcode.com/topic/66699…