2. 两数相加

链接

思路：先将链表转化为两个整数，再将两个整数相加得到和，再将和转化为链表，最终输出这个链表。

一个未能通过全部测试用例的解答：

C 代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

// 输入一个链表，输出一个整数
long long getNumber(struct ListNode* input) {
    long long res = 0;
    long long i = 0;
    while (input) {
        res += (input->val) * pow(10, i);
        ++i;
        input = input->next;
    }
    return res;
}

// 输入一个整数，输出一个链表。
// 从个位开始，向高位遍历，后插法。
struct ListNode* getList(long long input) {
    long long value = input % 10;
    struct ListNode* list = (struct ListNode*)malloc(sizeof(struct ListNode));
    list->val = value;
    list->next = NULL;
    struct ListNode* rear = list; // 尾指针
    input /= 10;
    while (input) {
        value = input % 10;
        struct ListNode* node =
            (struct ListNode*)malloc(sizeof(struct ListNode));
        node->val = value;
        node->next = NULL;
        rear->next = node;
        rear = node;
        input /= 10;
    }
    return list;
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    long long number1 = getNumber(l1);
    long long number2 = getNumber(l2);
    long long number = number1 + number2;
    struct ListNode* res = getList(number);
    return res;
}

测试用例通过情况：

1565 / 1569 个通过的测试用例

输入

l1 = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
l2 = [5,6,4]

输出

[-3,-4,-3,-5,-7,-7,-4,-5,-8,-6,-3,0,-2,-7,-3,-3,-2,-2,-9]

预期结果

[6,6,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]

如果代码中的数据类型不是 long long 而是 int，则能够通过的测试用例将会更少。但是使用 long 或者 long long 类型能通过的测试用例数量不变。

能完全通过的解答：

C 代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

// 两个链表中同一个位置的数字可以直接相加。
// 可以同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。
// 例如，如果当前两个链表相应位置的数字为 n1 和 n2，进位值为 carry，
// 则它们的和为 n1+n2+carry，
// 则答案链表中相应位置的数字为 (n1+n2+carry)%10，
// 新的进位值为 (n1+n2+carry)/10。
// 如果两个链表的长度不同，则可以认为长度较短的链表后面有若干个 0。
// 如果链表遍历结束后，有 carry > 0，还需要在答案链表的后面再附加一个结点，
// 结点的值为当前位置的进位值，即 carry。
// 本题中，carry 要么为 1，要么为 0。

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode *head = NULL, *tail = NULL;
    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 = malloc(sizeof(struct ListNode));
            tail->val = sum % 10;
            tail->next = NULL;
        } else {
            tail->next = malloc(sizeof(struct ListNode));
            tail->next->val = sum % 10;
            tail = tail->next;
            tail->next = NULL;
        }
        carry = sum / 10;
        if (l1) {
            l1 = l1->next;
        }
        if (l2) {
            l2 = l2->next;
        }
    }
    if (carry > 0) {
        tail->next = malloc(sizeof(struct ListNode));
        tail->next->val = carry;
        tail->next->next = NULL;
    }
    return head;
}