从零到一系列之两数相加-2

按照题意首先想到的就是先把链表转化为数字

相加之后再转化为要求的链表

代码如下:

class Solution {
public:
    ListNode* addTwoNumbers(ListNode *l1, ListNode *l2) {
        int res = getNextval(l1) + getNextval(l2);
        return getListNode(res);
    }
    /*
     * 链表转数
     */
    int getNextval(ListNode *l3) {
        if (l3->next != nullptr) {
            return l3->val + getNextval(l3->next) * 10;
        } else {
            return l3->val;
        }
    }
    /*
     * 数转链表
     */
    ListNode * getListNode(int res){
        if(res>0){
            ListNode *node = new ListNode(res % 10);
            node->next = getListNode(res/10);
            return node;
        }else{
            return nullptr;
        }
    }
};

这里是用递归实现的，但是这里提交之后遇到了一个问题那就是

两数输入为零的时候他会返回空值

所以加上特殊情况的考虑

ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        int res = getNextval(l1) + getNextval(l2);
        if (res == 0) {
            return new ListNode(res);
        }
        return getListNode(res);
    }

可是提交之后发现它会给一个很大的数，此时的int承载不下

使用long long之后也不能承载，他会使用一个32位的10进制数，这是超过long long的取值范围的

所以要想通过所有测试用例，满足100位输入数的需求，只能自己慢慢加

这样一来就需要考虑只需要考虑每次相加的进位问题即可

这是官解，考虑了头节点，相加结束之后进位保留

/*
 * current 模拟相加运算
 */
class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        ListNode *head = nullptr, *tail = nullptr;
        int carry = 0; //进位
        while (l1 || l2) {
            int n1 = l1 ? l1->val : 0;
            int n2 = l2 ? l2->val : 0;
            int sum = n1 + n2 + carry;
            if (!head) {//头节点
                head = tail = new ListNode(sum % 10);
            } else {
                tail->next = new ListNode(sum % 10);
                tail = tail->next;
            }
            carry = sum / 10;
            if (l1) {
                l1 = l1->next;
            }
            if (l2) {
                l2 = l2->next;
            }
        }
        if (carry > 0) {
            tail->next = new ListNode(carry);
        }
        return head;
    }
};

但是还是有点不甘心，还是想用递归完成

这是别人的写法，浅学了一下

class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        return dfs(l1, l2, 0);
    }
    ListNode *dfs(ListNode *l1, ListNode *l2, int carry) {
        if (!l1 && !l2 && !carry) {
            return nullptr;
        }
        int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
        ListNode *node = new ListNode(sum % 10);
        node->next = dfs(l1 ? l1->next : nullptr, l2 ? l2->next : nullptr, sum / 10);
        return node;
    }
};