LeetCode 热题 100—— 合并两个有序链表（链表）+ 两数相加（链表）

目录

21. 合并两个有序链表 简单

2. 两数相加 中等

---

简单

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

• 两个链表的节点数目范围是 [0, 50]

• -100 <= Node.val <= 100

• l1 和 l2 均按 非递减顺序 排列

//方法一：递归
//终止条件：当两个链表都为空时，表示我们对链表已合并完成。
//如何递归：我们判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果。（调用递归）
​
//时间复杂度：O(n+m)，其中 n 和 m 分别为两个链表的长度。因为每次调用递归都会去掉 l1 或者 l2 的头节点（直到至少有一个链表为空），函数 mergeTwoList 至多只会递归调用每个节点一次。因此，时间复杂度取决于合并后的链表长度，即 O(n+m)。
​
//空间复杂度：O(n+m)，其中 n 和 m 分别为两个链表的长度。递归调用 mergeTwoLists 函数时需要消耗栈空间，栈空间的大小取决于递归调用的深度。结束递归调用时 mergeTwoLists 函数最多调用 n+m 次，因此空间复杂度为 O(n+m)。
​
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

//方法二：迭代
/*
循环条件：当两个链表都不为空时，持续比较当前节点的值。
节点连接：将较小值的节点连接到prev的后面，并移动相应链表的指针。
指针后移：每次连接后，prev指针后移一位。
*/
​
//时间复杂度：O(n+m)，其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中，l1 和 l2 只有一个元素会被放进合并链表中， 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的，因此总的时间复杂度为 O(n+m)。
​
//空间复杂度：O(1)。我们只需要常数的空间存放若干变量。
​
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* preHead = new ListNode(-1);
​
        ListNode* prev = preHead;
        while (l1 != nullptr && l2 != nullptr) {
            if (l1->val < l2->val) {
                prev->next = l1;
                l1 = l1->next;
            } else {
                prev->next = l2;
                l2 = l2->next;
            }
            prev = prev->next;
        }
​
        // 当其中一个链表遍历完后，直接将另一个链表的剩余部分连接到prev的后面。
        prev->next = l1 == nullptr ? l2 : l1;
        
        return preHead->next;
    }
};

2. 两数相加 中等

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

• 每个链表中的节点数在范围 [1, 100] 内

• 0 <= Node.val <= 9

• 题目数据保证列表表示的数字不含前导零

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *head = nullptr, *tail = nullptr;
        //进位值
        int carry = 0;
        // 遍历两个链表，直到都处理完
        while (l1 || l2) {
            // 当前l1节点的值，若为空则取0
            int n1 = l1 ? l1->val: 0;
            // 当前l2节点的值，若为空则取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;
            }
            // 更新进位值（若sum≥10则carry为1，否则为0）
            carry = sum / 10;
            
            // 移动指针到下一个节点
            if (l1) {
                l1 = l1->next;
            }
            if (l2) {
                l2 = l2->next;
            }
        }
        // 处理最后可能的进位
        if (carry > 0) {
            tail->next = new ListNode(carry);
        }
        
        // 返回结果链表的头节点
        return head;
    }
};