链表coding

206. 反转链表 - 力扣（LeetCode）

 return reverse(cur,tmp);//注意写法！

24. 两两交换链表中的节点 - 力扣（LeetCode）

ListNode* dummy=new ListNode(0);//注意这个用法！

24. 两两交换链表中的节点 - 力扣（LeetCode）

你的大体思路是非常清晰和准确的！使用虚拟头节点（dummy node）和双指针（c1, c2）是解决合并有序链表最标准的做法。

你甚至想到了一步非常聪明的优化：当其中一个链表为空时，直接把另一个链表剩下的部分接上去（cur->next=c2; c2=NULL;）。

但是，你的代码中存在一个致命的遗漏，会导致合并出来的链表丢失数据。

🚨 核心 Bug 分析：忘记移动游标 cur

在你的 while 循环内部，当你把较小的节点接到 cur->next 之后，你移动了 c1 或 c2，但是你忘记把 cur 往后移了！

这会导致什么后果？

假设你要合并 [1] 和 [2]：

1. 第一次循环：c1 的值更小，你执行了 cur->next = c1。此时 dummy 连向了 1。然后 c1 变成了 NULL。

2. 第二次循环：进入 if(!c1) 分支，你执行了 cur->next = c2。

   • 注意！ 此时 cur 依然停留在 dummy 上！

   • 所以，你把 dummy->next 重新指向了 2。之前接上去的 1 被无情地覆盖并且丢失了。

3. 最终返回的 dummy->next 变成了 [2]，而不是完整的 [1, 2]。

修改方法：

每次给 cur->next 赋值之后，必须紧跟一句 cur = cur->next;，让这根“针”一直走到当前新链表的最尾端，准备迎接下一个节点。

💡 更优雅的写法建议

你目前使用的循环条件是 while(c1 || c2)，这迫使你在循环内部去检查 if(!c1) 和 if(!c2)，并且用 c2 = NULL; 这种有点 hack 的方式来强制退出循环。

在处理“合并有序”类问题（包括合并数组、归并排序）时，业界最标准、最清晰的写法是：while(c1 && c2)。

• 当两者都有节点时，比大小，谁小就挂谁。

• 只要有任何一个链表被遍历完了，循环立刻结束。

• 循环结束后，直接把没走完的那个链表“一锅端”挂到 cur 的后面。

✅ 修正与优化后的代码

结合上述两点，并补上我们之前提到过的“释放 dummy 内存”的好习惯，你的代码可以优化成这样：

C++

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* dummy = new ListNode(0);
        ListNode* cur = dummy;
        ListNode* c1 = list1;
        ListNode* c2 = list2;
        
        // 只有当两个链表都有剩余节点时，才需要比大小
        while (c1 != NULL && c2 != NULL) {
            if (c1->val < c2->val) {
                cur->next = c1;
                c1 = c1->next;
            } else {
                cur->next = c2;
                c2 = c2->next;
            }
            // 【关键修复】针眼必须往后移动，准备串下一个节点！
            cur = cur->next; 
        }
        
        // 循环结束时，必定至少有一个链表为空了。
        // 我们只需要把非空的那个链表直接挂到 cur 后面即可。
        if (c1 != NULL) {
            cur->next = c1;
        } else if (c2 != NULL) {
            cur->next = c2;
        }
        
        // 收尾工作
        ListNode* newHead = dummy->next;
        delete dummy; // 释放虚拟头节点
        return newHead;
    }
};

复杂度分析：

• 时间复杂度： $O(M+N)$，其中 $M$ 和 $N$ 是两个链表的长度。我们最多只遍历两个链表各一次。

• 空间复杂度： $O(1)$，我们只是在现有的节点之间修改指针（穿针引线），并没有开辟与链表长度相关的额外内存空间。