反转链表这问题，我在各种场合讲过无数遍了——带新人、带嵌入式团队、做技术面试官，几乎每个阶段都会遇到它。链表这种数据结构，学起来很有迷惑性：创建、遍历、插入、删除看着都挺直白，可真让你把一个单链表原地反转，能一次写对的人没几个。反转链表，也叫逆置链表，别看核心代码就十来行，它把指针暂存、断链顺序、边界处理、递归理解这些基本功全给串起来了。这篇博文我就把这道题从原理到多语言实现、从边界情况到嵌入式工程应用完整拆一遍，无论你是正在学数据结构的学生、准备笔面试的求职者，还是在项目里跟循环队列打交道的工程师，都能从中拿到一点实在东西。

大多数资料讲反转链表，上来就给你三行代码，然后配一句"思路就是这样"。真到自己动手，问题马上冒出来：为什么第一步要先存 next？递归里 head->next->next = head 到底在干嘛？空链表和单节点链表要不要单独处理？搞不清这些，代码抄一百遍也记不住。所以我换一种讲法：从最底层的链表遍历和插入说起，逐步引出三种反转方案，再给出 C、C++、Python、Java 四套可运行的实现，最后专门聊聊带头结点、循环链表这些变体里的坑。

1. 反转链表：题目背后的真实分量

1.1 为什么这道题能考倒一大片人

先说说这道题为什么"看着容易，上手就错"。反转链表不是独立操作，它是链表操作里最需要"同时协调多个指针"的场景。普通遍历只需要一个指针往后跳；插入需要一个新节点和两个指针配合；反转则需要三个指针协同，而且每一步都涉及"先保存、再修改、后跳转"。这个节奏一旦被打乱，链表结构就彻底崩了。

新手最容易踩的坑，就是先写curr->next = prev，然后发现下一个节点丢了。这不是粗心，而是对"链表遍历依赖指针跳转"理解不深：遍历时curr = curr->next能正常工作，是因为此时curr->next还指向原来的后继；反转时这个指针被改写了，原链表等于断了，所以第一步必须暂存 next。这种"先保底、再动手、后转移"的顺序，几乎贯穿所有改变链表结构的操作。

还有一个容易被忽略的点：反转后的头节点是原链表的最后一个节点。很多人写测试时发现反转后打印顺序对了，就直接交差，但你问他"现在 head 指向谁？"他答不上来。反转函数返回的是新头，调用者必须重新赋值。如果不重新赋值，后续遍历还是从旧头出发，而旧头此时已经是新尾，打印出来只有一个节点，看起来就像反转失败了。这其实跟算法本身没关系，纯粹是使用习惯问题，但浪费的调试时间一点也不少。

1.2 从链表遍历和插入说起

理解反转链表，绕不开链表遍历和链表插入这两个基本功。单链表的遍历就是从 head 出发，沿着 next 一直走，走到空指针为止。这个线性访问方式决定了单链表的根本特征：每个节点知道下一个是谁，但不知道上一个是谁。所以反转链表做的工作，本质上是给每个节点补上"前驱"信息——把单向关系改写成反方向。

链表插入里的头插法，更是反转的直接抽象。头插法的操作是：新节点先指向当前头，再把头更新为新节点。如果我对原链表的每个节点都做一次头插到新链表，完成后新链表的顺序正好颠倒。这个思路很多教材没有点破，但偏偏是最直观的入口。后面第 2.3 节我会专门展开。

另外，这次分享还会反复提到单循环链表、循环单链表这些变体。循环链表尾节点的 next 不是空指针，而是绕回链头，这种结构在嵌入式系统的环形队列、轮询任务里非常常见。直接对循环链表做反转，如果还死抱着while (curr != NULL)不放手，反转完会发现链表变成一个"半断半续"的怪胎。这个坑在第 4 章会细讲。

2. 方案选型：迭代、递归与头插法怎么选

2.1 迭代法：三指针的核心逻辑

迭代法是最经典、也最稳的方案。三个指针我用 prev、curr、next 来命名：prev 指向当前节点的前一个节点，curr 指向当前要处理的节点，next 暂存 curr 的原始后继。

循环体一共四步，顺序一步都不能换：

1. next = curr->next，保存后继，防止断链后找不回后面的节点。
2. curr->next = prev，把当前节点的指针掰向反方向，这就是"反转"动作。
3. prev = curr，前驱指针挪到当前节点。
4. curr = next，当前指针挪到原来的后继。

循环结束时curr为空，说明已经越过链表末尾。此时prev正好指向原链表的最后一个节点，也就是新链表的头节点，返回它就行。

时间复杂度 O(n)，只遍历一遍；空间复杂度 O(1)，只用了三个辅助指针。这套逻辑在任何语言里都一样，C 语言链表、Java 链表、Python 单链表逆序，换的只是语法外壳。记忆口诀我常用六个字："先保底、再动手、后跑路"。保底就是保存 next，动手就是把当前节点的指针反过来，跑路就是两个指针往前走。顺序写错，最常见的后果就是死循环或者空指针崩溃。

2.2 递归法：从后往前处理的心智模型

递归法代码更短，但对初学者极不友好。它的思路是：反转N1 -> N2 -> N3 -> N4，先假定从 N2 开始的子链表已经反转好，变成N4 -> N3 -> N2，剩下的工作就是把 N1 接到 N2 后面，同时把 N1 原来的 next 置空。

递归终止条件是当前节点为空，或者当前节点的 next 为空——也就是说，递归一路走到原链表的尾节点才开始返回，每层返回时把当前节点的后继指向自己。核心代码长这样：

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

最难悟的是head->next->next = head这句。举个例子：当前 head 是 N1，递归已经处理完 N2 到尾节点的部分，返回的 newHead 是 N4。递归在返回前，已经把后半段重排好了：N4->next = N3、N3->next = N2，并且N2->next当时被置为 NULL，所以 N2 现在是后半段链表的"临时尾巴"。现在要把 N1 接回链表，就必须让 N2 的 next 指向 N1，这正好就是head->next->next = head做的事。接着head->next = NULL把 N1 指向 N2 的原链断开，整条链表就变成了N4 -> N3 -> N2 -> N1 -> NULL，而递归一路上传的 newHead 始终是 N4。

递归优点是代码清晰、符合分治直觉；缺点是空间复杂度 O(n)，要占 n 层函数调用栈。普通 PC 上跑还好，但在嵌入式环境里，几 KB 的栈空间根本经不起递归霍霍。所以我的态度很明确：两种方法都要会，实际工程优先迭代。

2.3 头插法：从链表插入操作延伸出的思路

头插法本质上是把反转问题转化成了大家更熟悉的"链表插入"问题。做法是新建一个空链表头 newHead，初始为 NULL，然后遍历原链表，每次把当前节点摘下来，用头插法插到 newHead 的前面：

Node *reverseByHeadInsert(Node *head) { Node *newHead = NULL; Node *p = head; while (p != NULL) { Node *next = p->next; // 先保存后继 p->next = newHead; // 让 p 指向新链表的头 newHead = p; // 更新新链表的头 p = next; // 继续处理原链表的下一个节点 } return newHead; }

仔细对比你会发现，头插法和 2.1 的迭代法其实是同一个逻辑，只不过看问题的角度不同：迭代法强调"三个指针在一条链表上协同移动"，头插法强调"不断把节点搬到新链表的头部"。这个思维的转换相当有价值，尤其适合给新手做铺垫，因为它把反转问题退化成了更直觉的插入操作。学会了头插法，后面学局部链表反转、链表插入排序都会更容易上手。

三种方案怎么选？我的建议是：笔面试优先迭代，空间 O(1) 最稳妥；讲思路可以先头插法铺垫、再切迭代；递归作为补充，用于展示"从后往前"的思维层级。不要只背一种，面试官一句"还能不能换个方法"，多一种方案就多一分从容。

3. 多语言落地：C、C++、Python、Java 的代码与细节

3.1 C语言结构体链表的经典实现

C 语言做链表，最常用的是结构体节点加动态内存分配。我这边的标准写法如下：

#include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node; Node* createNode(int data) { Node *node = (Node*)malloc(sizeof(Node)); if (node == NULL) { printf("malloc failed\n"); exit(1); } node->data = data; node->next = NULL; return node; } void traverse(Node *head) { Node *p = head; while (p != NULL) { printf("%d -> ", p->data); p = p->next; } printf("NULL\n"); } Node* reverseList(Node *head) { Node *prev = NULL, *curr = head, *next = NULL; while (curr != NULL) { next = curr->next; curr->next = prev; prev = curr; curr = next; } return prev; } int main() { Node *head = createNode(1); head->next = createNode(2); head->next->next = createNode(3); head->next->next->next = createNode(4); printf("original: "); traverse(head); head = reverseList(head); printf("reversed: "); traverse(head); return 0; }

运行输出：

original: 1 -> 2 -> 3 -> 4 -> NULL reversed: 4 -> 3 -> 2 -> 1 -> NULL

几个细节值得说透。第一，malloc 后必须判空。练习代码很多人不判，但在嵌入式或者长时间运行的服务器进程里，内存分配失败并不罕见，一旦空指针解引用，轻则段错误，重则整个进程崩溃。第二，反转后必须把返回值重新赋给 head，否则 traverse(head) 打印的只有最后一个节点。这其实就是我第 1.1 节强调过的调用习惯问题。第三，变量名尽量用 prev、curr、next，而不是 p、q、r。这种具名方式能大幅降低读代码和 debug 的难度，尤其对初学者。

3.2 C++结构体链表基本语法实战

C++ 里写链表有两套风格：一套偏 C 风格，结构体加指针；另一套偏现代 C++，用构造函数和智能指针。热词里提到的 c++结构体链表基本语法，我重点说第一套风格里和 C 不一样的地方——构造函数。

LeetCode 风格的结点定义通常长这样：

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* reverseList(ListNode* head) { ListNode* prev = nullptr; ListNode* curr = head; while (curr != nullptr) { ListNode* next = curr->next; curr->next = prev; prev = curr; curr = next; } return prev; } };

C++ 相比 C 的核心优势是构造函数：直接new ListNode(1)就能得到一个完整节点，不需要单独写 createNode 函数。这在刷题时尤其方便，题目给的接口本身就是 ListNode，直接用。注意几个使用要点：第一，反转函数写在类里作为成员函数，返回 ListNode*，这是 LeetCode 的标准做法；第二，new 出来的节点用完要 delete，刷题可以不写析构，但工程上必须考虑内存释放；第三，用 nullptr 而不是 NULL，前者是 C++11 引入的类型安全空指针，不会和整数 0 混淆。

3.3 Python单链表逆序：简洁背后的注意点

Python 写链表的最大优点是语法清爽，最大坑是引用语义容易让人产生"变量赋值"的错觉。每个节点是对象，每个指针其实是对象引用。

class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def reverse_list(head: ListNode | None) -> ListNode | None: prev = None curr = head while curr is not None: nxt = curr.next curr.next = prev prev = curr curr = nxt return prev

python单链表逆序最容易出问题的反而不是算法本身，而是空值的判断。有人习惯写while curr:，在绝大多数场景下和while curr is not None等价，但如果节点类里自定义了__bool__或者__len__，while curr的判断结果可能完全出乎你的意料。做链表这种指针密集型算法，我强烈建议用is not None这种显式写法，一行代码换来所有场景下的确定性。Python 的递归版同样简洁：

def reverse_list_recursive(head: ListNode | None) -> ListNode | None: if head is None or head.next is None: return head new_head = reverse_list_recursive(head.next) head.next.next = head head.next = None return new_head

不过要提醒一句：Python 默认递归深度限制大约 1000 层，链表节点超过这个数会直接抛 RecursionError。所以 Python 里我更推荐迭代版。

3.4 Java链表的迭代与递归实现

Java 的链表节点用 class 定义，字段访问用.next，和 Python 类似，但类型系统是强静态类型。刷题时标准节点定义如下：

class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } class Solution { public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode curr = head; while (curr != null) { ListNode next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; } }

Java 的递归和 C 逻辑相同，核心还是head.next.next = head和head.next = null那两句：

class Solution { public ListNode reverseListRecursive(ListNode head) { if (head == null || head.next == null) { return head; } ListNode newHead = reverseListRecursive(head.next); head.next.next = head; head.next = null; return newHead; } }

说句掏心窝的话，Java 的题解网上遍地都是，但很多新手复制粘贴到 LeetCode 提交后，根本不懂为什么 prev 能一路带回最后一个节点。我的建议是：拿一张纸，画一个 3 节点的链表，手工推演每一步的指针变化。这个动作花不了五分钟，但对建立指针感特别有效。Java 日常开发里手写链表的机会不多，但 LinkedList、ConcurrentLinkedQueue 这些原生容器的源码里有大量节点指向操作，理解反转能帮你更容易读懂源码里的 next 变换逻辑，面试时还能延伸到 Java 集合底层，一举两得。

4. 边界场景：带头结点、循环单链表与空链表

4.1 不带头结点的单链表：最底层的操作方式

前面所有代码都是基于不带头结点的单链表——也就是 head 直接指向第一个有效数据节点。这是最底层、最"裸"的形态：链表为空就是 head 为空，找第一个节点就是 head 本身。这种形态下，所有涉及头节点的操作都要格外小心，因为头指针本身就是函数的入口，任何改变链表结构的操作都意味着返回值要更新。

不带头结点时，验证反转是否成功有个很简单的标准：从返回的新头出发，按 next 一路走，打印的序列应该是原序列的倒序，且走到空指针为止。不要只比对第一个和最后一个节点的值，那样会漏掉中间节点接错的情况。我在带新人时经常看到有人打印出来头尾对、中间乱，就是因为他只检查了两端。

4.2 带头结点链表的反转处理

带头结点的链表在工程代码里很常见，通常也叫哑节点。它有一个不存数据的哨兵节点在最前面，head 指向这个哨兵，真正的第一个数据节点是 head->next。这种设计能让插入、删除操作在逻辑上统一，不用特判"删除头节点"这种边界。

反转带头结点的链表，不能把哨兵也卷进去，哨兵必须保留在链头。正确做法是先记录第一个有效节点，从它开始反转，最后把哨兵的 next 指向新的头节点：

Node* reverseWithDummy(Node* head) { if (head == NULL || head->next == NULL) return head; Node *prev = NULL; Node *curr = head->next; while (curr != NULL) { Node *next = curr->next; curr->next = prev; prev = curr; curr = next; } head->next = prev; return head; }

注意返回值：带头结点链表的反转函数，最后返回的仍然是哑头节点本身，因为整个链表的"入口"没变。这一点和不带头结点的情况完全不同：不带头结点时外部 head 必须接收返回值，带头结点时 head 不需要重新赋值。如果你拿到一个链表，第一步就要确认它有没有哨兵节点，哨兵存不存数据，这直接决定反转算法的入口和返回值怎么写。很多实验课上出问题，就是因为把哨兵当成了普通节点一起反转，结果哨兵跑到了链表末尾，遍历全乱了套。

4.3 循环单链表反转的独特之处

循环单链表，也叫单循环链表，是嵌入式工程里特别常见的一种结构：尾节点的 next 不是空，而是绕回链头，整个链表形成一个环。轮询调度、环形缓冲、空闲任务队列，都爱用它，因为它天然适合"从头到尾再从头"的循环访问模式。

直接反转循环单链表有两个大坑。第一，终止条件不能用curr == NULL，因为循环链表里根本不存在空指针，如果用while (curr != NULL)会一直转死。第二，反转完成后必须重新接回闭环：原头变成新尾，新尾的 next 要指向新头；原尾变成新头，新头要成为调用方新的入口。

稳妥的做法是先把环拆开，当成普通链表反转，最后再把环接回去：

Node* reverseCircular(Node* head) { if (head == NULL) return NULL; Node* tail = head; while (tail->next != head) tail = tail->next; // 找到原尾节点 tail->next = NULL; // 暂时拆环 Node *prev = NULL, *curr = head, *next = NULL; while (curr != NULL) { next = curr->next; curr->next = prev; prev = curr; curr = next; } // 反转完成后，prev 是新头，head 变成新尾 head->next = prev; // 接回闭环 return prev; }

拆环、反转、回环，三步分开做，每一步都清晰可控。注意返回的新头是原尾节点，调用方如果继续使用旧的 head 变量，它现在指向的是新尾，再往后走一个 next 才回到新头。嵌入式代码示例里如果一个链表被多个模块引用，反转后所有相关的头指针引用都要同步更新，这是多指针指向同一结构的经典隐患。我处理这类问题时，习惯加一个单元测试：反转后从新头走一圈，确认能原路返回新头，且访问节点数与原链表一致，这样环的完整性才有保障。

5. 从实验到工程：应用场景与实践总结

5.1 嵌入式领域的链表应用与反转需求

说到嵌入式链表代码示例，有人会觉得"单片机里跑链表是不是太奢侈"。实际上链表在嵌入式里非常常见。RTOS 的任务就绪队列，很多实现就是把任务控制块串成循环链表，调度器在链表上轮询；串口接收的环形缓冲，用链表实现比固定数组灵活得多，尤其是处理不定长数据包的时候。

反转链表在嵌入式里虽然不像算法面试那么频繁，但也确实有真实的用武之地。比如设备需要倒序回放最近记录的日志，或者按时间倒序遍历一组传感器数据，把链表反转一下再输出，代码最直观。更常见的场景是缓冲区数据逆序处理。链表节点里存的不一定是数据本身，可能是内存块的指针，反转链表本质上是反转内存访问顺序，并不会大量拷贝数据，所以内存开销极低。

但嵌入式里有一个硬约束必须时刻牢记：栈空间极其有限。一次递归可能消耗几十到上百字节的栈，链表稍长就会触发栈溢出，导致系统复位。所以嵌入式环境下，反转链表几乎只使用迭代法。如果你在嵌入式项目里看到有人写递归版反转，那多半是没踩过裸机栈溢出的坑。

5.2 常见问题速查表

下面这张表是我带人时积累的常用排查表，基本覆盖了反转链表里绝大多数新手问题：

这张表里第一和第三条几乎占掉新手大半调试时间。我建议练习时先跑两个节点的用例，再跑三个节点，最后再上长链表随机验证。由小到大的调试习惯，比一上来就调一个 100 节点的长链表高效得多。

5.3 单链表基本操作实验的设计思路

如果你是在校学生，或者想系统性地把链表基础打牢，我强烈建议自己完整做一遍"单链表的基本操作实验"。这个实验的内容至少包括：初始化（尾插法创建）、遍历打印、查找、插入、删除，最后用反转链表作为"综合大题"。这个顺序有讲究，因为反转链表把前面所有操作都串起来了——你要理解插入如何改指针，要能遍历找尾节点，还要在反转之后用遍历来验证结果。

实验步骤可以这样设计：

1. 用尾插法创建一条 5 节点的单链表，依次存 1、2、3、4、5。
2. 写 traverse 函数，从 head 开始遍历打印，建立基线。
3. 写迭代反转函数，并让 head 接收返回值。
4. 再次调用 traverse，确认输出是 5、4、3、2、1。
5. 把 head 置空，调用反转函数，确认空链表不崩。
6. 只创建一个节点，反转后打印，确认单节点正常。
7. 改成带头结点，重复步骤 2、3、4，体会差异。
8. 把原链表改成循环链表，加上拆环-反转-回环流程，对比运行结果。

做完这八步，你对链表的理解会有一个质变。第 7、8 步尤其重要，因为很多人上课时能背代码，一上机就懵，就是缺少这种变体训练。我当年带嵌入式团队，面试时很喜欢丢一个带头结点的循环链表反转题目过来，能独立写对的人比例真不高，但凡是做过这个实验的人，基本都能在五分钟内完成，差距非常明显。

说实话，反转链表这个题目代码量小得可怜，但它就像链表操作里的"试金石"。我面试候选人时特别爱问这道题，不是考背诵，而是因为它把指针操作、边界条件、工程取舍、语言差异全串在了一起。能把这道题讲清楚的人，多半能搞定链表里大部分增删改查。所以我建议大家先别急着追求刷题量，把这个题反复写透，从 C 写到 C++、Python、Java，再从普通链表扩展到带头结点和循环链表，直到你能不看任何参考代码、在纸上十分钟内写出迭代和递归两版，这个基本功才算真正到位了。