LeetCode445.Add Two Numbers II题解

1. 题目描述

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.

2. Follow Up

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

3. 样例

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

4. 分析

这道题表面上看起来很好理解：即给出了A、B两个链表，我们需要做的事情是将两个链表的对应节点元素相加，得到一个新的链表。但是笔者在做这道题整整花了3个小时！因为最开始努力全部用链表来解，失败了，最后不得不转向熟悉的vector。
分析一下：由于给出的两个链表相加，我们的计算方式都是从低位向高位相加计算的，那么找到两个链表的最低位就成了做这道题的关键步骤：给定的是单向链表，我们没办法很容易的从链表尾开始遍历提取节点存储的数，那么将链表逆置成为了解题思路。虽然题目中follow up提出不要逆置原链表，于是我们用vector将原链表的数值存储起来算作打擦边球吧。
我们用两个vector得到了原来的逆向存储的链表，接下来的事情就容易很多了，每一位对应相加，注意考虑进位的问题，因此要有模10得到这一位的最终数值以及相似的方法求取每一位的进位。需要格外注意的是边界问题的处理：

Example1：
Input: (5) + (5)
Output: (1 -> 0)而非(0)
Example2：
Input: (1) + (9 -> 9)
Output: (1 - > 0 -> 0)而非(10 -> 0)

5. 源码（vector版本通过）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
        vector<int> getList(ListNode* h) {
        vector<int> L;
        int value;
        while(h) {
            value = h->val;
            L.push_back(value);
            h = h->next;
        }
        return L;
    }
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *l3 = NULL;
        vector<int> v1 = getList(l1);
        vector<int> v2 = getList(l2);
        reverse(v1.begin(), v1.end());
        reverse(v2.begin(), v2.end());
        vector<int> v3;
        int adds = 0;
        int temp = 0;
        if (v1.size() >= v2.size()) {
            while(v2.size()) {
                temp = (adds + v1.front() + v2.front()) % 10;
                adds = (adds + v1.front() + v2.front()) / 10;
                v3.push_back(temp);
                v1.erase(v1.begin()+0);
                v2.erase(v2.begin()+0);
            }
            while(v1.size()) {
                temp = (adds + v1.front()) % 10;
                adds = (adds + v1.front()) / 10;
                v3.push_back(temp);
                v1.erase(v1.begin()+0);
            }
            if (adds != 0) {
                v3.push_back(adds);
            }
        }
        else {
            while(v1.size()) {
                temp = (adds + v1.front() + v2.front()) % 10;
                adds = (adds + v1.front() + v2.front()) / 10;
                v3.push_back(temp);
                v1.erase(v1.begin()+0);
                v2.erase(v2.begin()+0);
            }
            while(v2.size()) {
                temp = (adds + v2.front()) % 10;
                adds = (adds + v2.front()) / 10;
                v3.push_back(temp);
                v2.erase(v2.begin()+0);
            }
            if (adds != 0) {
                v3.push_back(adds);
            }
        }
        ListNode *add = NULL;
        ListNode *curr = (ListNode*)malloc(sizeof(ListNode));
        curr->next = NULL;
        while(v3.size()) {
            add = (ListNode*)malloc(sizeof(ListNode));
            add->val = v3.front();
            v3.erase(v3.begin()+0);
            add->next = curr->next;
            curr->next = add;
        }
        l3 = curr->next;
        return l3;
    }
};

6. 链表版本（未通过）

这两种算法的基本思路是一样的，都是先求出原链表的逆向链表，然后建立新链表，对应项相加。只不过该版本可以直接利用头插法和尾插法去建立链表，但是好久没写代码了，发现自己链表的基本功都忘了差不多了，写的代码反复不过，这是GG。注意啊，以下是错的！！！！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void Reverse(ListNode *&h, ListNode *a, int &length) {
        ListNode* r;
        ListNode* s;
        ListNode* p;
        p = a;
        h = (ListNode*)malloc(sizeof(ListNode));
        h->next = NULL;
        r = h;
        while(p) {
            s = (ListNode*)malloc(sizeof(ListNode*));
            s->val = p->val;
            s->next = r->next;
            r->next = s;
            p = p->next;
            length++;
        }
    }
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *r1, *r2;
        ListNode *result = NULL;
        ListNode *curr = (ListNode*)malloc(sizeof(ListNode));
        curr->next = NULL;
        int length1 = 0, length2 = 0;
        Reverse(r1, l1, length1);
        Reverse(r2, l2, length2);
        r1 = r1->next;
        r2 = r2->next;
        ListNode *add;
        int adds = 0;
        int temp = 0;
        if (length1 >= length2) {
            while(r2) {
                temp = adds;
                temp += (r1->val + r2->val)%10;
                adds = (r1->val + r2->val) / 10;
                add = (ListNode*)malloc(sizeof(ListNode));
                add->val = temp;
                add->next = curr->next;
                curr->next = add;
                r1 = r1->next;
                r2 = r2->next;
            }
            while(r1) {
                temp = adds;
                temp += r1->val % 10;
                adds = r1->val / 10;
                add = (ListNode*)malloc(sizeof(ListNode));
                add->val = temp;
                add->next = curr->next;
                curr->next = add;
                r1 = r1->next;
            }
            result = curr->next;
        }
        else {
            while(r1) {
                temp = adds;
                temp += (r1->val + r2->val)%10;
                adds = (r1->val + r2->val) / 10;
                add = (ListNode*)malloc(sizeof(ListNode));
                add->val = temp;
                add->next = curr->next;
                curr->next = add;
                r1 = r1->next;
                r2 = r2->next;
            }
            while(r2) {
                temp = adds;
                temp += r2->val % 10;
                adds = r2->val / 10;
                add = (ListNode*)malloc(sizeof(ListNode));
                add->val = temp;
                add->next = curr->next;
                curr->next = add;
                r2 = r2->next;
            }
            result = curr->next;
        }
        return result;
    }

};

7. 心得

审题仍然很重要，边界考虑也很重要，否则会卡在很多边界的测试样例上面。学会转化思想，链表写法实在搞不定还是老老实实换成自己熟悉的vector吧，但这方面的基本功要复习了。