单链表反转后只输出一个节点？排查思路与实现细节

前几天在整理单链表模块时，遇到一个让我有点哭笑不得的bug：reverseList() 执行完之后，控制台只打出来一个节点。当时我盯着输出结果看了好几秒，第一反应是反转函数写得不对，接着又开始怀疑打印函数、怀疑测试用例，折腾了半个多小时，最后发现居然是返回值没有接住。

后来我把这个问题的排查过程和常见的几个“只输出一个节点”原因整理了一下，发现这类问题在链表题目里其实很典型，尤其是刚接触链表反转的人，很容易踩。这篇就聊聊链表反转后只输出一个节点的定位思路，以及单链表反转实现中那些容易忽略的细节。

1. 问题复现与现象分析

1.1 一个典型的“只输出一个节点”场景

假设你已经写出了一版看起来正确的单链表反转函数，迭代三指针法：

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* cur = head;
    while (cur != nullptr) {
        ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

这个函数本身没有任何问题。它会把 1 -> 2 -> 3 -> 4 反转为 4 -> 3 -> 2 -> 1，并且返回新的头节点 4。

然后你在调用处可能写了这样一段代码：

cpp复制ListNode* newHead = reverseList(head);
printList(head);

这时候打印结果是什么？是 1。

为什么？因为 head 这个变量在调用 reverseList 之前指向的是原链表的头节点 1。反转完成后，原来的头节点 1 已经被移动到了新链表的最后一个位置，它的 next 变成了 nullptr。所以你还拿原来的 head 去遍历，就只能看到 1 这一个节点，后面的节点全被“丢”了。

这个现象不是反转函数的逻辑错误，而是调用方使用了错误的指针。它非常隐蔽，因为代码能编译、能运行，看起来只是结果少了一点，你可能完全不会想到是调用处的问题。但实际工作中，这类问题出现的频率远比算法本身写错要高。

1.2 最小复现代码与日志输出

为了把问题说透，我构造了一个最小例子。首先是链表节点的定义和辅助函数：

cpp复制#include <iostream>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

void printList(ListNode* head) {
    while (head != nullptr) {
        cout << head->val;
        if (head->next != nullptr) cout << " -> ";
        head = head->next;
    }
    cout << endl;
}

然后在 main 里构造一个四节点链表，并分别打印 head 和返回值指向的链表：

cpp复制int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);

    cout << "before reverse: ";
    printList(head);

    ListNode* newHead = reverseList(head);

    cout << "print old head: ";
    printList(head);

    cout << "print return value: ";
    printList(newHead);

    return 0;
}

我实际运行后的输出是：

code复制before reverse: 1 -> 2 -> 3 -> 4
print old head: 1
print return value: 4 -> 3 -> 2 -> 1

看到这里，问题就很清楚了：旧的 head 只有它自己，返回值才是完整的反转链表。所以以后遇到这种“反转后只输出一个节点”的现象，第一反应不应该是去 debug 反转算法，而是先确认打印用的指针是不是反转后的新头。

1.3 第一轮排查：打印函数是否正常

我那次遇到问题时，第一件事是检查 printList 有没有写错。比如许多人会不小心把循环条件写成 while (head->next != nullptr)，这种情况下会漏掉尾节点，导致输出少一个。但如果链表很长，那应该少的是最后一个节点，而不是只剩第一个节点。所以打印函数导致“只输出一个节点”的可能性很小，除非你的链表本来就只有一个节点。

我当时在 printList 里临时加了一个计数器：

cpp复制int cnt = 0;
while (head != nullptr) {
    cnt++;
    head = head->next;
}
cout << "cnt=" << cnt << endl;

跑出来的结果是 cnt=1，这说明传入打印函数的节点，它的 next 确实是 nullptr。这意味着不是我打印漏了，而是这个节点就是孤零零一个。于是我把排查重心放到了反转函数和调用方式上，很快就定位到了问题。

2. 反转逻辑的核心要点与常见实现

2.1 为什么链表反转容易“断链”

单链表的结构决定了它天生“目光短浅”：每个节点只知道自己下一个节点是谁，不知道自己的前一个是谁。反转的本质，就是让每个节点的 next 指向它原来的前驱。

这原本不难，但难点在于：当你修改一个节点的 next 之后，原来它指向的那个节点就再也找不到了。用大白话说，一列火车每节车厢只连着下一节，现在要把整列火车的挂钩全部反过来。如果你先把第一节车厢和后面的车厢断开，却忘了记录第二节车厢在哪里，后面整列车厢就跟你失联了。

所以，所有正确的迭代反转实现，都必须先保存当前节点的原后继，再修改 next。这也是为什么说“三指针法”是基础中的基础。

2.2 迭代三指针法详解

迭代版本的核心代码再贴一次：

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* cur = head;
    while (cur != nullptr) {
        ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

三个指针的作用分别是：

• prev：当前节点的前一个节点，初始为 nullptr，因为原链表的头节点反转后要变成尾节点，它的 next 必须指向空。
• cur：当前正在处理的节点。
• next：暂存 cur->next，防止修改指针后丢失原始链表的后半段。

循环内部四步操作，顺序不能乱：

1. 保存原后继：next = cur->next
2. 反转：cur->next = prev
3. 把 prev 移动到当前节点
4. 把 cur 移动到原后继

用 1 -> 2 -> 3 手动模拟一遍：

• 初始：prev = nullptr，cur = 1。
• 第一次循环：next = 2，1->next = nullptr，prev = 1，cur = 2。
• 第二次循环：next = 3，2->next = 1，prev = 2，cur = 3。
• 第三次循环：next = nullptr，3->next = 2，prev = 3，cur = nullptr。

循环结束，prev 指向 3，也就是新链表的头，直接返回 prev。这个实现的空间复杂度是 O(1)，时间复杂度是 O(n)，是单链表反转的首选方案。

2.3 递归反转的边界处理

递归版本的写法也很常见，代码更简洁：

cpp复制ListNode* reverseListRecursive(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return head;
    }
    ListNode* newHead = reverseListRecursive(head->next);
    head->next->next = head;
    head->next = nullptr;
    return newHead;
}

理解递归版本的诀窍是：别想着一次看完所有节点，只关注当前层需要做什么。

假设当前 head 是 1，它后面的链表已经被递归函数反转好了，新头是原来的最后一个节点。在递归回溯回来后，链表结构大概是：

code复制1 -> 2 <- 3 <- 4

注意这里 2 的 next 指向了 3？不对，实际上递归返回回来后，2 的 next 已经指向 1？我们需要重新描述。

我用另一种方式解释：递归进入 head=1 时，调用 reverseListRecursive(2)，它会一直递归到最后的节点 4，4 是递归出口，返回 4。然后回溯到 head=3，此时 3->next 是 4，执行 head->next->next = head 就是把 4->next = 3，再执行 head->next = nullptr 防止环。这时 3 和 4 已经反转，返回的新头还是 4。继续回溯到 head=2，把 3->next = 2，2->next = nullptr。再回溯到 head=1，把 2->next = 1，1->next = nullptr。最终返回 4。

这个递归版本特别容易犯两个错误：

• 忘记写 head->next = nullptr，导致原头节点的 next 还指向第二个节点，形成环。
• 在调用处返回了 head，而不是递归函数返回的 newHead。因为 head 是原链表的头，反转后变成了尾节点，它的 next 已经被递归过程置空，所以用 head 去打印，结果也会是只有一个节点。

递归版本虽然代码短，但空间复杂度是 O(n)，在链表特别长的时候有栈溢出的风险。工程上我通常不会用递归，除非是做题或者链表长度确定很短。

2.4 返回值选错是“只输出一个节点”的最常见原因

不管用迭代还是递归，反转后链表的头节点一定变了。迭代返回的是 prev，递归返回的是 newHead。如果你在调用处仍然用原来的 head 变量去访问链表，那必然会出现“只输出一个节点”的现象，因为原来的头节点已经变成了新链表的尾节点，它的 next 是 nullptr。

很多教科书上的示例代码会写 head = reverseList(head);，目的就是直接覆盖原来的头指针，避免后续误用。我的习惯是额外用 newHead 变量，名字上做出区分，这样代码可读性更好，也能减少低级错误。

注意：反转函数通常返回 ListNode*，除非你用引用传参 ListNode*& head 或二级指针，否则函数内部的移动不会改变外部的 head 指针。这也是很多人“明明函数写对了，但外面用起来还是错”的根源。

3. 实操排查与最终修复

3.1 从头到尾定位问题

如果你也遇到了反转后只输出一个节点的现象，建议按下面这个顺序排查，基本三分钟能定位：

第一步，构造一个最简单的测试链表，比如 1 -> 2 -> 3，反转前先打印一次，确认链表构造正确。

第二步，调用 reverseList，在调用处打印返回值：

cpp复制ListNode* r = reverseList(head);
cout << "return value = " << r->val << endl;

如果返回值和反转前的头节点相同，那说明反转函数本身有问题；如果返回值是原链表的尾节点，那说明函数没问题，问题出在调用方。

第三步，分别打印原来的 head 和返回值 r 指向的整个链表。

我那次得到的日志是：

code复制before reverse: 1 -> 2 -> 3 -> 4
return value: 4
print old head: 1
print return value: 4 -> 3 -> 2 -> 1

这个日志已经非常明确：反转函数返回值正常，但原 head 指向的节点已经变成尾节点。修复方式就是把调用处的 head 更新为返回值，或者直接全部使用 newHead 变量。

3.2 三个隐蔽 bug 复盘

除了“返回值没接住”之外，还有几个隐蔽 bug 也会导致类似现象。我把它们整理出来，方便你做代码 review 时对照。

第一个 bug：循环中先修改 next，再想取原后继。

cpp复制while (cur != nullptr) {
    cur->next = prev;
    prev = cur;
    cur = cur->next;  // 错误：cur->next 已经被改成 prev 了
}

这段代码第一次循环后，cur 就变成了 prev，也就是原来的头节点，然后循环会出问题。链表在这里断开，结果可能只输出一个节点或者空链表。

第二个 bug：头插法反转时忘记移动指针。

头插法也是常见的反转实现：

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode* newHead = nullptr;
    while (head != nullptr) {
        ListNode* next = head->next;
        head->next = newHead;
        newHead = head;
        head = head->next; // 错误：这里 head->next 已经不是原后继了
    }
    return newHead;
}

第一次循环时，head 是节点 1，执行完 head->next = newHead 后，head->next 变成了 nullptr。这时候再执行 head = head->next，head 直接变成空，循环结束。结果就是只反转了第一个节点，后面的节点全部丢了，newHead 链表只有一个节点。这个 bug 的典型现象就是“只输出一个节点”。

正确的写法是最后移动指针时用提前保存的 next：

cpp复制ListNode* next = head->next;
head->next = newHead;
newHead = head;
head = next;

第三个 bug：递归版本漏掉 head->next = nullptr。

递归版本如果只写了 head->next->next = head;，但没有把 head->next 置空，那么原头节点和第二个节点之间会形成环。打印翻转后的链表时，如果遍历到原头节点，可能又沿着环绕回前面，轻则输出重复节点，重则死循环。这个 bug 虽然不一定是“只输出一个节点”，但也是最容易让人头晕的隐蔽问题。

3.3 修复后的完整可运行代码

把所有问题修掉后，我最终用的是下面这版代码，直接在 main 里完成反转和打印：

cpp复制#include <iostream>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* cur = head;
    while (cur != nullptr) {
        ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

void printList(ListNode* head) {
    while (head != nullptr) {
        cout << head->val;
        if (head->next != nullptr) cout << " -> ";
        head = head->next;
    }
    cout << endl;
}

int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);

    cout << "before reverse: ";
    printList(head);

    head = reverseList(head);

    cout << "after reverse: ";
    printList(head);

    return 0;
}

运行结果：

code复制before reverse: 1 -> 2 -> 3 -> 4
after reverse: 4 -> 3 -> 2 -> 1

关键就在 head = reverseList(head); 这一步，把新链表的头节点交给原来的 head 变量，后面打印就不会错了。

如果你用 Python，思路完全一样：

python复制class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseList(head):
    prev = None
    cur = head
    while cur:
        nxt = cur.next
        cur.next = prev
        prev = cur
        cur = nxt
    return prev

Python 里同样要注意：head = reverseList(head) 之后，原来的 head 变量才指向新头。

3.4 测试用例补充

调试链表问题时，我习惯整理一张测试用例表，尤其是边界情况，别嫌它简单，往往 bug 就是边界条件下才暴露的。

我在实际调试中还喜欢把创建链表的逻辑封装成一个函数，比如用 std::initializer_list 快速构造链表，这样每次测试不用写一堆 new。

4. 常见问题与排查技巧实录

4.1 还有哪些情况会导致“只输出一个节点”

除了前面说的“忘记接收返回值”，还有一些其他场景。比如有的人写的反转函数签名是 void reverseList(ListNode* head)，然后在函数内部写 head = newHead;，以为这样就能把新头部传出去。

实际上这是错误的。函数参数 head 是形参，是一个局部变量，你改变它并不会影响外部的 head 指针。只有传 ListNode*& head 引用，或者传二级指针 ListNode** head，或者在函数里返回新头，才能把修改带出来。如果你用了 void 版本，外部打印旧 head，结果自然是只输出一个节点。

还有一种情况：带头节点的链表。很多教材里链表会有一个不存数据的哑节点，真正的数据从头节点的 next 开始。反转的时候，如果处理不当，打印函数又直接从头节点开始遍历，那么打印出来的可能是哑节点的 next 所指向的新头，看起来不是只输出一个节点。但如果你把哑节点也当成了普通节点，反转后就会乱套。所以遇到链表时，先确认到底是有头节点还是没有头节点。

4.2 指针操作自查清单

我自己总结了一份链表反转的自查清单，每次写完代码对照一遍，能省很多 debug 时间：

• 修改 cur->next 之前，是否保存了原来的后继节点？
• 循环结束时，是否确定 cur 已经指向 nullptr？
• 返回的是 prev（迭代版），而不是 cur？
• 递归版是否正确地把 head->next 置空？
• 调用处是否把返回值赋给了 head，或者使用了 newHead？
• 空链表、单节点这两个边界用例测了吗？

如果这几点都确认了，那反转算法的正确性基本就有保障了。

4.3 调试技巧：日志、小规模用例、画图

链表的 bug，靠肉眼盯代码有时候真的盯不出来。我常用的调试三件套：

第一，打日志。在循环里把 prev、cur、next 都打印出来，看每一步的指针走向。比如：

cpp复制while (cur != nullptr) {
    ListNode* next = cur->next;
    cout << "prev=" << (prev ? prev->val : -1)
         << " cur=" << (cur ? cur->val : -1)
         << " next=" << (next ? next->val : -1) << endl;
    cur->next = prev;
    prev = cur;
    cur = next;
}

日志一打，立马能看到是第几步开始节点丢了。

第二，用小规模用例。很多人一调试就用几十个节点的链表，数据一多，眼都花了。我一般先用 1 -> 2 -> 3，最多 1 -> 2 -> 3 -> 4。手动模拟三四个节点，逻辑漏洞很容易暴露。

第三，画图。不要嫌画图老土，链表指针问题用笔在纸上画箭头，比盯着代码想快得多。我曾经有个 bug，看了半天代码都觉得没问题，结果在纸上画完才发现 cur 已经跑到错误的位置上了。

5. 延伸：链表反转的几个变体与边界控制

5.1 反转前 N 个节点

理解了基本反转，马上会遇到变体：反转链表的前 N 个节点。思路和完整反转差不多，但要注意边界。

实现可以借用头插法，反转前 N 个节点后，原链表的第 N 个节点变成新头，原第 N+1 个节点变成了新链表的尾节点，它的 next 要接到原第 N+1 个节点上。如果处理不好，同样会出现只输出一个节点的现象。

cpp复制ListNode* reverseFirstN(ListNode* head, int n) {
    ListNode* prev = nullptr;
    ListNode* cur = head;
    while (n-- > 0) {
        ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    head->next = cur; // 关键：把反转部分的尾节点接到剩余链表
    return prev;
}

这里的 head 是原第一个节点，反转后变成了尾部，它的 next 必须指向 cur（原第 N+1 个节点）。漏掉这一步，就会只输出前 N 个节点中的一个，或者完全丢失后半段。

5.2 反转区间 [m, n] 的链表

再进一步，反转链表中从第 m 个节点到第 n 个节点的部分。这题在面试里比单纯全链表反转更常见。

基本思路是：

1. 先找到第 m-1 个节点，记为 front。
2. 反转从 m 到 n 的区间，返回反转后的头 newHead 和尾 tail。
3. 把 front 的 next 指向 newHead，把 tail 的 next 接到原第 n+1 个节点。

这个问题的边界很恶心，尤其是 m=1 时，没有前驱节点；n=链表长度时，尾部要置空。如果处理不当，打印结果就会“少一节”或“只输出一节”。我建议先写一个辅助函数 reverseList，然后在这个基础上做拼接，不要在一个函数里硬怼所有逻辑。

5.3 每 K 个一组反转

还有一个高频题：每 K 个节点一组反转，不足 K 个的部分保持原样。这其实是前面所有知识点的综合。

分组反转时，每一组都需要“掐头去尾”地处理边界：组内用三指针反转，组间要记录上一组的尾节点，用来连接下一组的头。这个场景里最容易出现的 bug 和前文一样：指针更新顺序错了，或者没有保存上下组之间的连接点，结果整个链表断成几截。

如果你在练习这些变体，建议始终遵循一个原则：只关注当前需要修改的指针，修改前先把原来的关系存下来，修改后马上校验前后两个方向的连接。链表的绝大多数异常输出，都逃不出“断链”和“用错头指针”两类问题。

那次 bug 解决之后，我给自己的代码里加了一条要求：所有会改变链表头节点的操作，调用处必须重新赋值。变量命名上也尽量用 newHead 而不是复用 head，避免随手写 reverseList(head) 然后把返回值扔了。链表反转本身并不难，难的是养成指针边界意识。如果你也遇到反转后只输出一个节点，先别急着怀疑反转函数，去调用处看一眼返回值接住没有，大概率就是它。