链表反转后只输出一个节点？根因分析与修复指南

链表反转后只输出一个节点，这个问题我见的次数实在太多了。不只是刚学数据结构的新手会踩，工作了几年的开发者有时也会在这种看似基础的操作上翻车。明明逻辑感觉没问题，代码也编译通过了，一跑才发现整个链表只剩一个节点，或者遍历半天只打印出第一个元素。今天我就把这个问题从根因到修复再到调试，一次性讲透。这篇文章适合正在学C/C++链表、准备算法面试、或者工作中被链表操作坑过的读者，内容不绕弯子，直接给到能落地的结论。

我先把结论放在前面：链表反转后只输出一个节点，绝大多数情况不是反转算法本身写错了，而是链表在你的操作里被“打断”了。所谓打断，要么是某个节点的 next 指针指向了错误的位置，要么是头节点指针漂移了，要么是遍历/打印时条件判断写错，导致链表实际变成单节点或者访问直接停留在第一个节点。下面我按“现象 → 原理 → 错误代码诊断 → 健壮实现 → 排查速查表”的顺序一步步拆解，把我这些年积累的实操经验全部放进来。

1. 现象描述：搞懂“只输出一个节点”到底意味着什么

在我处理过的链表问题里，“反转后只输出一个节点”这个现象可以细分成几种不同的表现。第一种最常见：你在反转函数里明明写了循环，也返回了一个指针，但调用的地方遍历链表时，只打印出链表里第一个节点的数据，就像链表从此再也没有下一个节点了一样。第二种表现更迷惑：打印出来确实有一个节点，但那个节点看起来既像第一个节点又像最后一个节点，数据对不上，甚至打印完程序直接卡死。第三种表现则是，反转后链表看起来只有一两个节点，中间那段凭空消失了，或者链表变成了一个环，遍历进去就出不来。

先别急着改代码。要判断问题出在哪一层，首先要确认一件事：你是不是在反转函数内部，无意中动了“头节点指针”本身？这是新手最容易踩的坑。很多人的反转函数把传入的 head 当作普通游标来用，一边移动一边改 next，循环结束后 head 已经跑到了链表的某个中间节点甚至 NULL，然后函数再把 head 返回出去。调用方拿着这个已经漂移的“头”去遍历，自然看到的节点数不对。比如原链表五个节点，head 在循环里一路走到了最后一个节点，外面再遍历就只能输出一个节点。

另一个高频原因是循环里指针更新的顺序错了。链表反转的核心操作是“把当前节点的 next 指向前一个节点”，但如果你在修改 next 之前没有把后面的节点先保存下来，那么一旦执行 cur->next = prev，原本跟在 cur 后面的那部分链表就再也找不到了。这相当于在一条铁轨上，你把当前车厢的挂钩从前一节车厢上摘下来，挂到了后面那节车厢上，但后面那节车厢本身已经断开，整个后半段列车就脱轨了。链表从中间裂成两段，你看到的自然只剩一个或少数几个节点。

还有一类问题发生在递归写法里。递归反转的核心想法是你信任子问题的解，也就是“head->next 后面的链表已经被反转好了”，然后你只需要把当前节点接上去。这是正确的模型。但很多人在递归返回时，把返回值和参数搞混了——函数返回的是新链表的头，但内部又用了旧链表的头去拼接，甚至忘了将原头节点的 next 置空。这样会形成环，一旦遍历就死循环，表现上有时会反复输出同几个节点，有时因为循环条件恰好为假，只打印一个节点就停掉了。这个现象我在教学时见过太多次，后面我会把错误代码贴出来逐行走一遍。

所以，“只输出一个节点”的本质是：链表的结构已经被破坏，不再是“一条从 head 出发、通过 next 一步步走完所有节点的完整链条”。你的打印函数没问题，但你喂给它的链表已经不是完整的链表了。

2. 链表反转的核心原理：迭代、递归两种写法的正确姿势

在讨论错误之前，必须把正确模型讲明白。链表和数组最大的区别在于，数组元素在内存里连续存放，你可以通过下标 O(1) 访问任意元素；链表节点在内存里是散落的，它们之间靠指针“牵着”彼此，你只能从头节点出发，沿着 next 一步步走。所以要反转链表，本质上不是交换数据，而是调整相邻节点之间的指向关系，让原本指向下一个节点的指针，反过来指向前一个节点。

先看迭代法。它是所有链表反转的基础，也是后面排查问题的出发点。

迭代法的标准写法是维护三个指针：prev、cur、next。初始时 prev 指向 NULL，cur 指向头节点 head，next 先不去管。每轮循环做三件事：先把 cur->next 保存到 next 里；再把 cur->next 改成 prev；然后把 prev 和 cur 都向后移动一步。循环直到 cur 为空，最后 prev 就是新链表的头。

这三步的顺序一个都不能乱。尤其是第一步，必须先把 cur 的下一个节点存下来。为什么？因为第二步一旦执行，cur->next 就指向 prev 了，原链表里 cur 后面的部分就被“丢”了——如果你没有提前保存 next，后面再也没有任何变量指向那段链表。你可以把 cur 想象成正在调头的列车车头，cur->next 就是车头后面的车厢，你在拐弯之前必须先让后面的车厢被另一台机车接住，否则一拐弯，车厢就脱节了。

这个保存动作，专业说法叫“暂存后继节点”。它的意义不是你多写一行代码而已，而是防止在修改指针时丢失对链表的访问权。很多由“只输出一个节点”这类 bug 追根溯源，都指向这一行被漏掉或者顺序错位。

递归法的模型则不同。它的核心思想是“我先把 head->next 后面的链表反转好，再处理 head”。你不需要关心子链表内部是怎么反转的，你只需信任递归函数返回的结果是新子链表的头。假设链表是 1 → 2 → 3 → 4 → 5，在递归栈最深那层，head 是 5，返回 5。回溯到 head 是 4 的那一层时，子链表 5 → NULL 已经被反转成 5 → NULL（单个节点无变化），此时你要做的操作是 head->next->next = head，也就是让 4 的下一个节点 5 的 next 指向 4；再执行 head->next = NULL，断开原来 4 → 5 的指向。这样 5 → 4 → NULL 就形成了。一步步回溯，最终得到 5 → 4 → 3 → 2 → 1。

这里最关键的细节就是 head->next = NULL。很多递归版错误都出在这里：忘记把当前节点的 next 置空，导致两个节点互相指向，形成环。递归版最后返回的是 newHead，不是 head。你如果返回了 head，外部拿到的就是旧链表的头，而此时旧链表的头已经变成整个链表的尾巴了，打印它当然只看到一个节点，或者打印它的 next 会发现又回到了倒数第二个节点，形成死循环。

这两种方法我都强烈建议你亲手实现一遍。不是背代码，而是在纸上画出每一步的指针变化。我见过很多同学对迭代法了然于心，但递归法只要一离开模板就出错，原因就是没从“子问题已经被解决”这个抽象层次去理解递归，而是用迭代的思路人肉模拟每一层递归栈，模拟着模拟着就乱了。

3. 典型错误代码逐行诊断：三条最常见的翻车路径

3.1 错误一：先改 next，再取 next，后半段链表彻底丢失

这是我见到次数最多的错误，代码大概长这样：

c复制// 错误示例：链表越改越短
struct Node* reverse_bad(struct Node* head) {
    struct Node* prev = NULL;
    struct Node* cur = head;
    while (cur != NULL) {
        cur->next = prev;          // 先把当前节点的next指向前一个节点
        prev = cur;                // prev移动到当前节点
        cur = cur->next;           // 想要移动到下一个节点，但cur->next已经变了！
    }
    return prev;
}

我们走一遍执行过程，假设链表是 1 → 2 → 3 → 4 → 5。初始 prev = NULL，cur = 节点1。

第一轮：cur->next = NULL，节点1 的 next 变成 NULL；prev = 节点1；cur = cur->next，注意此时 cur->next 已经是 NULL 了，所以 cur 变成 NULL。循环结束，函数返回 prev，也就是节点1。外面拿着节点1去遍历，只能输出一个节点，因为它的 next 就是 NULL。

问题出在第三行：cur->next 被修改之后，你再用 cur->next 去取原本的下一个节点，拿到的已经是“反转后的指针”，原来链表里 cur 后面的部分全丢了。用生活化的比喻，你先把车厢 A 的挂钩挂到了车厢 B 后面，再去车厢 A 后面找车厢 C，发现车厢 A 后面已经什么也没有了，但车厢 C 其实还停在原来的轨道上，只是你手上没有任何变量能访问到它了。

正确的做法，是先用 next 指针保存 cur->next，再修改 cur->next：

c复制struct Node* reverse_ok(struct Node* head) {
    struct Node* prev = NULL;
    struct Node* cur = head;
    while (cur != NULL) {
        struct Node* next = cur->next;  // 必须先保存后继
        cur->next = prev;
        prev = cur;
        cur = next;                     // 移动时用保存好的next
    }
    return prev;
}

这个版本里，取 next 的动作发生在修改 cur->next 之前，所以不管后续怎么改，总能通过 next 找到剩余链表。执行完循环，prev 指向原链表的尾节点，也就是新链表的头。

3.2 错误二：用 head 本身当游标，头节点漂移到末尾

第二种翻车路径隐蔽性更强。代码表面看起来逻辑没问题，但对链表迭代不熟悉的人很容易写出类似这样的版本：

c复制// 错误示例：头节点指针被移动，返回的“头”已经不是真正的头
struct Node* reverse_bad2(struct Node* head) {
    struct Node* tmp = NULL;
    while (head != NULL) {
        tmp = head->next;
        head->next = tmp;   // 看起来什么都没做，或者逻辑混沌
        head = tmp;         // head不断后移
    }
    return head;
}

这段代码写到后面，head 已经指向 NULL，所以返回 NULL，外部访问空指针直接崩溃；如果多加一个临时变量稍作修改，head 可能停在最后一个节点，外部遍历时打印一个节点后，发现 next 是 NULL，表现就是“反转后只输出一个节点”。

理解这个问题，要抓住一个关键点：形参 head 在函数内部只是一个局部变量，你对它的修改不会自动同步给外部。所以函数的返回值，必须是反转后真正的头节点。如果你在循环里把 head 当游标使用，那么循环结束时 head 一定位于链表的末端或 NULL，把这个值返回出去，外部拿到的根本不是链表的头。

我见过有同学这样“修复”：把返回值从 head 改成另一个变量，但那个变量没有在正确时机赋值，最后还是错。正确思路是，明确谁才是“新链表的头”——迭代完成后，prev 指针指向的就是新头。你不应该让 head 离开它原来的位置，或者说，即使你用了 head 做初始化，最后也必须有一个专门变量指向新头。

3.3 错误三：递归返回值错位或忘记断开尾指针，链表成环

递归版本的经典错误写法：

c复制// 错误示例：忘记head->next置空 + 返回了旧头
struct Node* reverse_bad3(struct Node* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct Node* newHead = reverse_bad3(head->next);
    head->next->next = head;
    // 忘记写 head->next = NULL;
    return head;  // 错误：这里应该返回newHead
}

这个版本的问题极其典型。我们以 1 → 2 → 3 为例。递归压栈三层：head=1 调 head=2 调 head=3。head=3 满足条件，返回 3。回溯到 head=2：newHead = 3；执行 2->next->next = 2，也就是 3 的 next 变成 2；没有执行 2->next = NULL；返回 head，也就是返回节点 2。回溯到 head=1：newHead = 2；执行 1->next->next = 1，即 2 的 next 变成 1；返回 head，也就是节点 1。最终外部拿到节点 1，沿着 next 走：1 → 2 → 3 → 2 → 1 → 2……链表成了一个环。

外部如果按普通方式遍历这个链表，while(cur != NULL) 永远为真，死循环；如果打印函数里有限制循环次数的逻辑，可能只打印前几个节点，看起来就像“只输出一个节点”。而实际原因不在于打印，而在于链表已经变成环形结构，不再是合法的线性链表。

正确写法是每个递归层级都必须把当前节点的 next 置为 NULL，并且返回 newHead：

c复制struct Node* reverse_recursive(struct Node* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct Node* newHead = reverse_recursive(head->next);
    head->next->next = head;
    head->next = NULL;
    return newHead;
}

为什么 head->next = NULL 是必须的？因为在正确的递归回溯过程中，head 原本是指向 head->next 的，这一对“父子关系”在反转后要变成“子指向父”。如果不把父节点（head）的 next 断掉，那么父节点还会继续指向子节点，父子互相指向，链环就出现了。你可以理解为：你让儿子反过来抱住父亲，就必须先把父亲牵着儿子的手松开，否则两个人抱成死结，谁都出不来。

3.4 附加错误：打印遍历条件写错

有时候链表反转本身没问题，但输出函数只打印了一个节点。比如打印循环写成：

c复制// 错误示例：条件判断漏掉最后一个节点
while (node->next != NULL) {
    printf("%d ", node->data);
    node = node->next;
}

这个循环在 node 的 next 为 NULL 时退出，也就是说最后一个节点不会被打印。如果原链表有 N 个节点，这个写法打印 N-1 个节点；如果 N=2，那就只打印 1 个节点。这虽然不是“反转后只输出一个节点”的全部原因，但恰好也会出现类似现象。排查时建议把打印循环改成 while(node != NULL)，保证每个节点都被访问到。

我习惯把“遍历链表”和“修改链表”两件事分开调试。先确保打印函数绝对正确，再去看反转逻辑。否则两个模块互相干扰，查问题会浪费大量时间。

4. 手写一份健壮的反转实现：从防御性编程到测试验证

4.1 C语言完整示例：构造、反转、打印、释放

既然要做排查和验证，我们直接写一份完整可运行的 C 语言代码，包含链表的创建、反转、打印和内存释放。这段代码我在很多项目里当模板用，你可以直接复制改数据。

c复制#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* createNode(int data) {
    Node* n = (Node*)malloc(sizeof(Node));
    if (n == NULL) {
        fprintf(stderr, "malloc failed\n");
        exit(EXIT_FAILURE);
    }
    n->data = data;
    n->next = NULL;
    return n;
}

void printList(Node* head) {
    Node* cur = head;
    while (cur != NULL) {
        printf("%d", cur->data);
        if (cur->next != NULL) {
            printf(" -> ");
        }
        cur = cur->next;
    }
    printf("\n");
}

Node* reverseIterative(Node* head) {
    Node* prev = NULL;
    Node* cur = head;
    while (cur != NULL) {
        Node* next = cur->next;  // 关键：暂存后继
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

Node* reverseRecursive(Node* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    Node* newHead = reverseRecursive(head->next);
    head->next->next = head;
    head->next = NULL;
    return newHead;
}

void freeList(Node* head) {
    Node* cur = head;
    while (cur != NULL) {
        Node* next = cur->next;
        free(cur);
        cur = next;
    }
}

int main() {
    Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("原链表: ");
    printList(head);

    head = reverseIterative(head);
    printf("迭代反转后: ");
    printList(head);

    head = reverseRecursive(head);
    printf("递归再反转回来: ");
    printList(head);

    freeList(head);
    return 0;
}

运行结果如下：

text复制原链表: 1 -> 2 -> 3 -> 4 -> 5
迭代反转后: 5 -> 4 -> 3 -> 2 -> 1
递归再反转回来: 1 -> 2 -> 3 -> 4 -> 5

这段代码里我特别加了空指针检查、内存释放和打印里的空格处理。很多人调试链表反转问题，用 printf 打印时没注意最后一个节点后面要不要跟箭头，其实这倒无所谓，真正重要的是：如果你发现输出结果“少了一截”，先别怀疑打印，先怀疑链表结构本身。

4.2 Python 版本的对照实现

Python 写链表没有指针概念，用的是对象引用。虽然不会出现 C 里那种“指针漂移”的写法错误，但“先保存后继”的顺序错误依然可能发生，而且表现方式更隐蔽。

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


def reverse_iterative(head):
    prev = None
    cur = head
    while cur is not None:
        next_node = cur.next
        cur.next = prev
        prev = cur
        cur = next_node
    return prev


def reverse_recursive(head):
    if head is None or head.next is None:
        return head
    new_head = reverse_recursive(head.next)
    head.next.next = head
    head.next = None
    return new_head


def build_linked_list(arr):
    dummy = ListNode()
    cur = dummy
    for val in arr:
        cur.next = ListNode(val)
        cur = cur.next
    return dummy.next


def print_linked_list(head):
    vals = []
    while head:
        vals.append(str(head.val))
        head = head.next
    print(" -> ".join(vals))


if __name__ == "__main__":
    head = build_linked_list([1, 2, 3, 4, 5])
    print("原链表:", end=" ")
    print_linked_list(head)

    head = reverse_iterative(head)
    print("迭代反转后:", end=" ")
    print_linked_list(head)

    head = reverse_recursive(head)
    print("递归再反转回来:", end=" ")
    print_linked_list(head)

Python 版本调试有个便利点：你可以直接打印链表中节点的 id，判断两个变量是不是指向同一个对象。比如在每次循环里打印 id(cur) 和 id(next_node)，就能肉眼观察到指针的移动过程，这对理解链表操作非常有帮助。

4.3 防御性编程和边界条件

一个好的反转函数必须处理三类边界输入：空链表、单节点链表、两个节点的链表。空链表返回 NULL；单节点链表直接返回该节点；两个节点的情况是检验你循环逻辑的最小测试用例。如果反转函数在两个节点上都出错，那说明你的指针更新顺序有问题。

防御性编程层面，我建议在函数入口做参数检查：

c复制if (head == NULL || head->next == NULL) {
    return head;
}

这一行对迭代法和递归法都适用，可以提前排除大部分边界问题。另外在 C 语言里，每次 malloc 后都要检查指针是否为 NULL，释放内存时要先把 next 保存下来再 free，防止悬垂指针。这些都是老生常谈，但链表代码里最容易酿成大事故的往往就是这些小地方。

4.4 地址打印法：肉眼观察指针走向

排查链表问题时，我最推荐的方法是在关键步骤打印节点地址。这个方法在 C 语言里特别好用：

c复制printf("prev=%p cur=%p next=%p\n", (void*)prev, (void*)cur, (void*)next);

在循环里加上这一行后，你能清晰地看到三个指针的移动轨迹：prev 慢慢向右走，cur 跟着走，next 在每一步都指向 cur 原来的后继。如果某一步 next 打印出来的地址不对，或者 cur 移动后指向的内容不再沿着原链表走，问题基本就能定位到这一步。

我在教别人调试链表时经常说：链表问题不要靠猜，要靠画图和打印。你脑子里的“想象执行”和 CPU 的实际执行经常不一致，编译器又不会告诉你逻辑错误。把每一步指针的地址打出来，数据说话，问题自然暴露。

5. 问题排查速查表与调试心法

5.1 常见问题与定位方法速查

我自己在实践中总结了一张速查表，遇事不决先对照一遍，省去乱试的时间。

这张表覆盖了我在工作里遇到的九成链表反转问题。很多时候问题并不是发生在反转算法本身，而是出现在调用方式上。比如有些人忘了把返回值赋回去：

c复制reverse(head);        // 错误：返回值被丢弃
printList(head);      // 打印出来还是原链表，或者看起来没变

这也是一个隐蔽的错误。反转函数返回新头，但调用方没有接收，外部还是用旧 head 遍历，表现可能是“反转了但没反转”，或者因为 head 此时指向尾节点，打印出来只有一个节点。正确写法是：

c复制head = reverse(head);
printList(head);

5.2 调试链表的实战心法

除了速查表，我想再分享几个我反复使用的心法。

第一，反转前后分别打印一次链表地址序列。所谓地址序列，就是从 head 出发，沿着 next 把所有节点的地址都打印一遍。反转前是一个有序地址序列，反转后应该变成逆序地址序列。如果反转后打印的地址序列断了，或者少了一段，说明那只手在中间某个位置“松手”了。这个方法比打印数据 value 更可靠，因为数据可能有重复，地址不会骗人。

第二，用最小用例反复测试。不要拿 10 个节点的链表去调试，两个节点足够暴露 90% 的问题。两个节点反转后，第二个节点必须变成头，且第一个节点的 next 必须是 NULL。这个用例都过不了，别急着加节点数。

第三，画图。我知道这句话听起来像老师上课说的废话，但链表的指针操作本质就是对图的修改。你在纸上画出节点、箭头，然后用橡皮擦掉旧的箭头、画上新的箭头，整个过程和代码执行是一一对应的。特别是递归法，不画图很容易把回溯逻辑搞混。

第四，利用调试器单步执行。GDB 里用 p *cur 查看当前节点内容，在循环条件上打断点，观察 cur 指针怎么移动。如果懒得用 GDB，打印法也完全够用。关键是不要让程序黑盒跑完，你要把中间状态暴露出来。

第五，给反转函数单独做单元测试。我建议你为反转逻辑写一个最简单的断言测试：构造链表，反转，再正序访问一遍，和期望值对比。这种测试一旦写好，以后每次写链表算法都可以复用。C 里可以简单用 assert，Python 里可以用 unittest。不要觉得小题大做，链表这种代码，出 bug 的成本远高于写测试的成本。

5.3 从“反转输出一个节点”扩展到链表调试通用思维

这个问题虽然具体，但背后反映的是链表操作通用思维：任何修改链表结构的操作，都要提前想清楚哪些指针会在修改后失效，哪些信息必须在修改前保存。这不只适用于反转，插入、删除、交换节点，本质上都是同一套思维方式。

比如删除链表节点时，你会先保存要删除节点的 next，再修改前驱的 next，最后 free 掉删除节点。这个“保存后继”的思路和反转时一模一样。再比如交换相邻两个节点，如果不先保存一堆临时指针，三下五除二就会把链表搅成乱麻。链表操作里，临时指针不是多余的，它是你的安全绳。

另外还有一个经验：不要在链表操作里玩“省变量”的小聪明。有些人觉得定义太多临时指针不优雅，试图用两个指针完成三个指针的工作。链表反转我见过各种“精简版”，最终大多在边界条件上翻车。三指针模型就是最稳的模型，多一个临时变量的开销完全可以忽略，你省下的那点内存和不优雅换来的却是正确性的风险，完全不值得。

我在实际带人时会发现，很多人把代码拿给我看时，问题早就不是“输出一个节点”了，而是已经被改得面目全非，逻辑里全是补丁。遇到这种情况，我的建议永远是：删掉重写，用一个干净的迭代三指针版本替换所有复杂逻辑。链表反转的正确实现就那几行，你不需要什么奇技淫巧，你只需要把基本模型背熟，理解每行代码为什么存在。这样下次再遇到类似问题，你扫一眼代码就知道哪里会断。