面试必刷Top101-BM11 链表相加(二)

​ 本专栏持续更新牛客题目解题思路及代码，欢迎感兴趣的朋友收藏⭐专栏持续关注，共同进步
专栏直达地址：牛客刷题

描述

假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。

给定两个这种链表，请生成代表两个整数相加值的结果链表。

数据范围：0 ≤ n , m ≤ 1000000，链表任意值 0 ≤ val ≤ 9
要求：空间复杂度 O(n)，时间复杂度 O(n)

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

示例1

输入：[9,3,7],[6,3]

返回值：{1,0,0,0}

示例2

输入：[0],[6,3]

返回值：{6,3}

备注

1 ≤ n,m ≤ 10^6
0 ≤ ai​,bi​ ≤ 9

解题思路

我们都知道，两个数的加法运算是需要从后向前算的，但是单链表只能从前向后，所以我们可以先将链表反转，计算完之后再反转回去就可以了

需要注意的点

1. 注意进位，用一个变量保存后一位的进位，在计算每一位时加上进位值

2. 计算完成后，要把链表反转再返回

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    // 反转链表
    ListNode* ReverseList(ListNode* head) {
        if(head==nullptr)
            return head;
        ListNode* cur = head;
        ListNode* prev = head->next;

        cur->next = nullptr;
        while(prev)
        {
            ListNode* next = prev->next;
            prev->next=cur;
            cur=prev;
            prev=next;
        }

        return cur;
    }

    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // 任意链表为空，则直接返回另一个
        if (!head1)
            return head2;
        if (!head2)
            return head1;

        // 反转两个链表
        head1 = ReverseList(head1);
        head2 = ReverseList(head2);

        // 进位符
        int carry = 0;
        // 创建新链表用来存放计算结果
        ListNode* newHead = new ListNode(-1);
        newHead->next = nullptr;
        ListNode* cur = newHead;

        // 遍历连个链表
        while(head1 || head2 || carry)
        {
            int val1 = (head1 == nullptr) ? 0 : head1->val;
            int val2 = (head2 == nullptr) ? 0 : head2->val;

            int num = (val1 + val2 + carry) % 10;
            carry = (val1 + val2 + carry) / 10;
            ListNode* newNode = new ListNode(num);
            // 将结点连接到新链表后
            newNode->next = cur->next;
            cur->next = newNode;
            cur = cur->next;

            if (head1)
                head1 = head1->next;
            if (head2)
                head2 = head2->next;
        }

        // 结果需要反转
        return ReverseList(newHead->next);
    }
};