【力扣】合并两个有序链表

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

我的方法：正常操作。这个题卡了我好几次。

首先是卡在内层 while 循环后，怎么去连接。要找到最后的比 q 小的 p，但是 while 终止时 p 已经比 q 大了。本来考虑 p->next 和 q 比较，后来发现本质上是缺一个 p 前面的指针，用 r 记录下来即可。

然后发现内存 while 需要先判断 p 和 q 是不是空，否则会访问空指针。然后又发现初始指针的判断条件应该和 while 中一致，都是 p <= q 才行。然后又发现内层 while 外面要加一个 if 判断，不然 p 没有动的时候，r->next = q 依然会执行。

折腾了半天，修修补补，总算完事了。

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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if (!list1) return list2;
        if (!list2) return list1;
        ListNode* p = list1;
        ListNode* q = list2;
        ListNode* r = p->val <= q->val ? p : q;
        ListNode* res = r;
        while (p && q) {
            if (p && p->val <= q->val) {
                while (p && p->val <= q->val) {
                    r = p;
                    p = p->next;
                }
                r->next = q;
            }
            if (p && q && q->val <= p->val) {
                while (q && q->val <= p->val) {
                    r = q;
                    q = q->next;
                }
                r->next = p;
            }
        }
        return res;
    }
};

题解方法1：思路跟我一致。有两点值得学习。

首先是 ListNode* preHead = new ListNode(-1)，造了一个假节点作为开始，而且写得很规范，避免了野指针。

另一种大大简化链接列表问题的方法是 “Dummy node” 节点技巧 ，所谓 Dummy Node 其实就是带头节点的指针。 ——力扣

其次是 while 循环，只有一层；而我多用了两个，还加了两个 if。它其实每一步在构造新的链表，只不过是在原有的基础上，而这每一步就是一次循环。

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;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev->next = l1 == nullptr ? l2 : l1;

        return preHead->next;
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

题解方法2：递归。

有人总结递归的关键思路如下：

• 这个问题的子问题是什么
• 当前层要干什么事情
• 递归出口

这道题的子问题是合并，当前层要把下层排序结果，拼接到自己这里，递归出口是指针为空。

    public ListNode mergeTwoLists(ListNode linked1, ListNode linked2) {
        if (linked1 == null)
            return linked2;
        if (linked2 == null)
            return linked1;
        if (linked1.val < linked2.val) {
            linked1.next = mergeTwoLists(linked1.next, linked2);
            return linked1;
        } else {
            linked2.next = mergeTwoLists(linked1, linked2.next);
            return linked2;
        }
    }

作者：数据结构和算法
链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/xnnbp2/?discussion=1mcRST
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

分析完了，可能下次还是不会递归，但至少能有思路了。