【数据结构基础_链表】Leetcode 2.两数相加

原题连接：Leetcode 2. Add Two Numbers

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Example 2:

Input: l1 = [0], l2 = [0]
Output: [0]

Example 3:

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,1]

Constraints:

• The number of nodes in each linked list is in the range [1, 100].
• 0 <= Node.val <= 9
• It is guaranteed that the list represents a number that does not have leading zeros.

---

方法一：模拟

思路：

模拟竖式运算
每一位的结果等于当前位的两个数和上一位的进位的和

c++代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        // 进位标志 head为头指针 tail为尾指针
        int flag = 0;
        ListNode *head = nullptr, *tail = nullptr;

        while(l1 != nullptr || l2 != nullptr){
            // 计算当前的结果
            int a = l1 != nullptr ? l1->val : 0;
            int b = l2 != nullptr ? l2->val : 0;
            int sum = a + b + flag;

            // 添加到链表中
            if(!head){
                head = tail = new ListNode(sum % 10);
            } else {
                tail->next = new ListNode(sum % 10);
                tail = tail->next;
            }

            // 更新flag
            flag = sum / 10;

            // 指针向后移动
            if(l1) l1 = l1->next;
            if(l2) l2 = l2->next;
        }

        // 最后还有进位的情况
        if(flag){
            tail->next = new ListNode(flag);
        }

        return head;
    }
};

复杂度分析：

• 时间复杂度：O(n + m)，需要遍历两个链表
• 空间复杂度：O(1)，返回值不考虑复杂度