1. 题目拆解与思路定调
1.1 这道题到底在考什么
“剑指 Offer 06. 从尾到头打印链表”是链表专题里非常经典的入门题，也是面试高频题。表面上看只是“倒着输出一串数字”，但真正考察的点其实有三个层次：第一，你知不知道链表的物理结构——它是单向的，只能从头到尾遍历；第二，你能不能灵活运用“栈”或者“递归”这种后进先出的逻辑来反转顺序；第三，你对 C 语言内存管理的敏感度——到底该用辅助数组、动态数组还是原地逆置，各有代价。
很多同学一看到“从尾到头”就想着“把链表反转后再遍历”，这思路本身没问题，但在面试场景里要谨慎。因为题目通常只要求“打印”，没有要求“修改链表结构”，你贸然把链表反转了，虽然也能输出正确结果，但会改变原链表的状态。如果面试官后续还有其他基于原始链表的问题，你就给自己挖坑了。所以我们优先考虑的是“不改动原链表结构”的方案。
1.2 为什么 C 语言做这道题特别有含金量
如果你用 Java、Python 做这道题，栈和递归几乎是“白给”的。Java 有现成的Stack类、Collections.reverse，Python 可以list[::-1]一行搞定。但 C 语言不一样，它没有内置的容器库，一切都要自己动手。这意味着你必须真正理解栈的底层实现、递归的调用栈开销、动态内存的分配与释放，甚至还要自己构造测试用例、管理链表内存。一道看似简单的题，在 C 语言环境下会把你对指针、结构体、内存布局的掌握程度暴露得清清楚楚。
我见过不少同学在 C 语言里写这道题，思路完全正确，但挂在了“如何存储结果”这一步：用固定数组怕不够大，用二级指针传参搞不清楚，用递归又担心栈溢出。这篇文章我就把自己常用的几种解法、踩过的坑、以及面试现场怎么和面试官沟通，一次性讲清楚。
2. 链表的基础认知与代码准备
2.1 链表结点的定义
这里必须强调一个细节：面试题里的链表结点定义，通常和 LeetCode 上略有不同。LeetCode 的 C 语言版本给你的是：
struct ListNode { int val; struct ListNode *next; };但剑指 Offer 原书的定义是带ListNode类型别名的：
typedef struct ListNode { int val; struct ListNode *next; } ListNode;这两种写法在刷题时都会遇到。LeetCode 里提交代码时，函数签名是：
int* reversePrint(struct ListNode* head, int* returnSize);注意这里没有 typedef，所以你在函数内部声明指针时要写成struct ListNode*。有些同学自己在本地测试时重新定义了带 typedef 的版本，结果和 LeetCode 环境冲突，编译报错，这属于很常见的“环境适配”问题。我的习惯是在本地写两种都有，理解它们的差异即可。
题目返回的是int*，也就是一个数组，数组长度通过returnSize指针带出去。这里要特别留意：C 语言函数返回数组，绝不能返回局部数组的指针（那是未定义行为，栈上的内存函数结束就没了），必须用malloc动态分配。这是整个实现里最关键的 C 语言考点。
2.2 测试环境的准备
很多同学刷题从来不自己写测试用例，这是大忌。链表这种数据结构，你不亲手创建几个带环的、带空指针的、超长的链表去跑一跑，根本发现不了问题。我的测试代码通常长这样：
#include <stdio.h> #include <stdlib.h> struct ListNode { int val; struct ListNode *next; }; // 根据数组创建链表，用于测试 struct ListNode* createList(int arr[], int n) { struct ListNode dummy; dummy.next = NULL; struct ListNode* tail = &dummy; for (int i = 0; i < n; i++) { struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode)); node->val = arr[i]; node->next = NULL; tail->next = node; tail = node; } return dummy.next; } // 释放链表，防止内存泄漏 void freeList(struct ListNode* head) { struct ListNode* cur = head; while (cur) { struct ListNode* next = cur->next; free(cur); cur = next; } } int main() { int arr[] = {1, 3, 2}; struct ListNode* head = createList(arr, 3); int returnSize = 0; int* result = reversePrint(head, &returnSize); for (int i = 0; i < returnSize; i++) { printf("%d ", result[i]); } free(result); freeList(head); return 0; }这里我用了一个带dummy头结点的小技巧，避免处理空链表的边界条件。如果你看不懂这段代码，说明链表基础还不太扎实，建议先去补一补结点插入的基础操作再回来做题。不打无准备之仗，这在面试里同样适用——你连测试环境都搭不利索，现场写代码会非常被动。
3. 解法一：遍历计数 + 逆序填充
3.1 思路解析
这个解法是我最推荐面试现场优先讲的，因为它思路最直观、代码最不容易出错，而且完全不动原链表。
第一步，先遍历一遍链表，数清楚一共有多少个结点，记为len。第二步，malloc一个长度为len的整型数组。第三步，再次从头遍历链表，但是这次我们从数组的最后一个位置开始往前填。
为什么可以这样做？因为数组支持随机访问，我们可以先确定“结果数组”的最后一个下标是len - 1，然后每遍历到一个结点，就把它的值放到当前下标位置，随后下标往前移动一位。遍历结束后，数组里的元素自然就是链表从尾到头的顺序了。
3.2 完整代码实现
int* reversePrint(struct ListNode* head, int* returnSize) { struct ListNode* cur = head; int len = 0; while (cur) { len++; cur = cur->next; } int* result = (int*)malloc(len * sizeof(int)); if (result == NULL) { *returnSize = 0; return NULL; } cur = head; int index = len - 1; while (cur) { result[index--] = cur->val; cur = cur->next; } *returnSize = len; return result; }3.3 时间和空间复杂度分析
时间复杂度是 O(n)，因为遍历了两次链表，常数因子是 2，但大 O 表示法下仍然是 O(n)。空间复杂度方面，如果不算返回结果数组本身的空间，辅助空间是 O(1)。如果算上返回数组，那就是 O(n)，但这是题目要求必须返回的，所以通常我们对外宣称“额外辅助空间 O(1)”。
这个解法的最大优势是安全、稳定。两次遍历虽然是常数时间的翻倍，但 n 本身不大，链表题通常限制在十万量级以内，2 倍常数完全不是问题。面试时如果面试官问“能不能只遍历一次”，你再顺势引出下面的栈解法，会显得你思维有层次。
提示：这种“先遍历求长度，再填充结果”的思路，其实是一个通用套路。很多题目要求返回数组、且数组大小和链表长度相关时，都可以这么做。类似的还有“链表中倒数第 k 个节点”的两次遍历版本。学会一个套路，往往能解决一类题。
4. 解法二：利用栈的后进先出特性
4.1 为什么栈天然契合这道题
“从尾到头打印”本质上就是一个“后进先出”的需求：越靠后的结点，越要越早输出。这和栈的特性完全一致。你可以把链表遍历一遍，逐个把值压入栈中，然后依次弹栈输出。这个过程完全不修改链表本身，只是借助了栈这个辅助结构来反转顺序。
很多高级语言里栈是现成的，C 语言则需要自己用数组模拟。但这里有一个非常巧妙的事情：我们其实不需要真的写一个独立栈结构，只需要先用一遍遍历确定链表长度，然后直接malloc一个数组，把遍历得到的值按顺序从下标 0 开始放入这个“栈数组”，最后再从数组末尾往前输出即可。这本质上就是“用数组模拟栈”，和第一种解法的代码几乎一样，但思维路径完全不同。
4.2 显式栈实现
int* reversePrint(struct ListNode* head, int* returnSize) { struct ListNode* cur = head; int len = 0; while (cur) { len++; cur = cur->next; } int* stack = (int*)malloc(len * sizeof(int)); if (stack == NULL) { *returnSize = 0; return NULL; } int top = 0; cur = head; while (cur) { stack[top++] = cur->val; cur = cur->next; } // 此时 top == len，从栈顶往栈底输出 int* result = (int*)malloc(len * sizeof(int)); if (result == NULL) { free(stack); *returnSize = 0; return NULL; } for (int i = 0; i < len; i++) { result[i] = stack[--top]; } free(stack); *returnSize = len; return result; }这个版本用了两个数组：一个模拟栈的输入缓冲，一个存最终结果。其实可以优化成只用一个数组——也就是第一种解法的做法。但面试时如果面试官让你“用栈的思想实现”，你把两个数组的结构讲清楚，更能展示你对栈这个概念的理解，而不是仅仅背了一个答案。优化的过程可以在代码写完后再提，加分效果非常明显。
4.3 显式栈 vs 递归栈
说到栈，必然有人会问：那直接用递归行不行？当然行，递归的本质就是系统帮你维护了一个调用栈。每递归到一个结点，先不打印，等递归返回后再打印，这样就实现了从尾到头输出。代码如下：
void reversePrintHelper(struct ListNode* head, int* result, int* index) { if (head == NULL) { return; } reversePrintHelper(head->next, result, index); result[(*index)++] = head->val; } int* reversePrint(struct ListNode* head, int* returnSize) { struct ListNode* cur = head; int len = 0; while (cur) { len++; cur = cur->next; } int* result = (int*)malloc(len * sizeof(int)); if (result == NULL) { *returnSize = 0; return NULL; } int index = 0; reversePrintHelper(head, result, &index); *returnSize = len; return result; }递归写起来非常简洁优雅，但它有两个隐患：一是链表很长时，递归深度可能达到上万层，C 语言默认的函数调用栈空间有限，容易发生栈溢出（Stack Overflow）；二是递归调用有额外的函数调用开销，性能不如显式栈。面试里如果你选择了递归写法，一定要主动提一句“递归本质上隐式使用了函数调用栈，链表过长时可能会栈溢出”，这句话能让面试官刮目相看。
5. 解法三：反转链表后顺序打印
5.1 反转链表的利与弊
既然是“从尾到头”，那最暴力的思路就是把链表整个反转，然后从头到尾打印。反转链表的经典写法是三指针法：
struct ListNode* reverseList(struct ListNode* head) { struct ListNode* prev = NULL; struct ListNode* cur = head; while (cur) { struct ListNode* next = cur->next; cur->next = prev; prev = cur; cur = next; } return prev; }反转之后，原来的尾结点变成了新链表的头结点，顺序遍历打印即可。
但这个方案有一个致命缺点：它修改了原链表的结构。如果题目允许修改，那没问题；但剑指 Offer 这道题原来的要求是“打印”，并没有说“允许修改”。面试官可能会追问“你这样做会不会影响后续操作？”这时候如果你没有意识到这个问题，就掉进陷阱了。
所以我的建议是：反转链表这个解法，不要在面试一开始就抛出，而是作为“额外讨论”放在最后。你可以说：“如果题目允许修改原链表，还可以用反转法，把链表反转后顺序打印，时间复杂度 O(n)、额外空间 O(1)。但如果题目隐含要求不修改原链表，就不推荐。”这样的回答展示了你对题目边界条件的思考，非常加分。
5.2 反转法完整实现
int* reversePrint(struct ListNode* head, int* returnSize) { // 先反转链表 struct ListNode* prev = NULL; struct ListNode* cur = head; int len = 0; while (cur) { struct ListNode* next = cur->next; cur->next = prev; prev = cur; cur = next; len++; } // 此时 prev 指向新链表的头（即原链表的尾） int* result = (int*)malloc(len * sizeof(int)); if (result == NULL) { *returnSize = 0; return NULL; } cur = prev; int index = 0; while (cur) { result[index++] = cur->val; cur = cur->next; } *returnSize = len; // 如果不想改变原链表，可以在这里把链表再反转回去 // restore... return result; }如果你要在“不修改原链表”的前提下用反转法，那就需要在打印完之后再把链表反转回去，相当于做两次反转。虽然多了一次遍历，但从对外表现看，原链表恢复到初始状态了。这个方法在“不允许修改原链表”的约束下，额外空间 O(1)，但时间上是三次遍历。和栈解法相比没有绝对优势，不过在面试讨论中提及，能体现你对约束条件的深刻理解。
6. 内存管理与常见坑汇总
6.1 returnSize 为什么必须是二级指针
题目签名中的int* returnSize是一个指向整数的指针，函数内部要给它赋值，告诉调用者返回数组有多长。如果你写成int returnSize然后直接returnSize = len;，在外面根本收不到这个值，因为 C 语言函数参数默认是值传递，你修改的只是形参。只有通过指针才能把长度“带出去”。这是 C 语言初学者最容易犯的错误。
同理，如果你在函数内部改变了head指针的指向，那么调用者的head不会改变，除非你传的是struct ListNode** head。这道题里我们不需要修改head，所以传一级指针就够了。
6.2 malloc 后忘记检查返回值
严格的代码规范要求：malloc之后必须判断返回的指针是否为NULL。虽然刷题平台通常不会刻意制造内存分配失败，但实际工程项目中这是必须考虑的分支。我相信很多同学刷题时不写这个判断，也能通过全部测试用例。但从代码质量的角度说，加一个判断并不费事，还能显示你考虑问题更周全。面试现场如果你写了空指针检查，面试官对你的印象分会提高。
6.3 数组下标越界的隐患
在第一种解法里：
int index = len - 1; while (cur) { result[index--] = cur->val; cur = cur->next; }这里index的取值为len-1到0，最后一次写入后index变成-1，循环结束。这个写法是正确的，但你心里要清楚index的边界。如果你不小心把len和索引搞混，比如从len开始写，就会越界访问，轻则崩溃，重则在 LeetCode 上出现 “AddressSanitizer: heap-buffer-overflow” 报错。这类错误最难排查，因为本地不一定能复现。
我自己的习惯是在写完这个循环后立刻做一个逻辑推演：假设链表长度是 0，那么len = 0，malloc(0)得到什么？C 标准允许返回NULL或者非NULL，但使用它都是未定义行为。不过题目大概率不会给空链表，返回空数组即可。如果想严格处理空链表，可以在len == 0时直接分配一个长度为 0 的数组（有些平台允许返回 NULL 并设置 returnSize=0）。为了稳妥，我通常在返回前加一个判断：
if (len == 0) { *returnSize = 0; return NULL; }虽然 LeetCode 对空链表返回result = NULL也能接受，但不同题目的判题器行为可能不同，这个防御性判断能避免边界条件的坑。
6.4 内存泄漏问题
这道题里，函数内部malloc出来的数组由调用者负责释放。LeetCode 的判题系统会自动接管，但你在自己写测试程序时，一定要记得free(result)和free链表各结点。我见过很多同学本地跑测试，程序退出前不释放内存，虽然操作系统会回收，但一旦你把测试代码和业务代码混在一起，内存泄漏会越积越多。平时养成随手释放的习惯，面试时万一面试官让你写main函数测试，你也能从容收尾。
7. 面试现场的表现策略与代码风格
7.1 先沟通，再动手
面试官给出这道题后，不要闷头就写。先确认几个关键点：“链表是否可以修改？”“返回的结果数组是否需要自己分配内存？”“空链表应该返回什么？”这些问题看起来琐碎，但能够展现你的工程思维。面试官欣赏的从来不是闷头写代码的“码农”，而是能够明确需求边界、避免返工的人。
7.2 从最优解写起还是从暴力解写起
我的建议是：先说出最简单的思路，哪怕它不够完美，然后立刻补充优化方案。比如你可以说：“最直接的做法是两次遍历，第一次数长度，第二次倒着填充数组，这样时间复杂度 O(n)、额外空间 O(1)。当然也可以用栈，思路更自然但额外空间 O(n)。如果允许修改原链表，可以用反转法做到额外空间 O(1)。”这段话一出口，说明你对这道题的所有常见解法已经胸有成竹，面试官通常会点头让你写其中一种。
7.3 代码风格要注意什么
刷题代码不像项目代码那样要求严格的日志、错误处理，但有几个风格点值得注意：
变量命名要有意义：
cur、prev、next、index、len这类短名字在算法代码中完全 OK，但不要用a、b、c这种毫无信息量的名字。保持缩进统一，连续赋值
result[index--] = cur->val;是常见写法，但如果你觉得容易混淆，可以拆成两行。面试时写的代码首先是给人看的，其次才是给机器跑的。写代码的同时可以小声口述你的思路，这样面试官能实时跟上你的节奏，也能在你有小错误时第一时间提醒。
写完代码后，自己举一个小的测试用例，比如
1->3->2，沿着代码逻辑走一遍，验证输出是2 3 1。这个过程叫“代码走查”，是面试中最能体现工程素养的环节。如果你能主动做，面试官基本不需要再帮你检查。
8. 举一反三：这道题还能衍生出哪些考点
8.1 从尾到头打印单链表的所有变体
如果把“链表”换成“数组”，那就是直接反向遍历数组，没有任何难度。但如果把“链表”换成“文本文件内容”，从尾到头打印每一行，那就涉及文件读取和栈存储，复杂度立刻提升。面试官会根据你的水平调整扩展方向，但核心思想始终是“后进先出”和“随机访问”。
8.2 双向链表会怎么变
如果题目给的是双向链表，那每个结点都有前驱指针，直接从尾结点开始往前遍历即可，根本不需要栈、递归或反转。这反过来说明，单向链表的“受限性”正是这道题的趣味所在。理解数据结构本身的特性，比盲目套模板重要得多。
8.3 如果要求“原地逆置且返回新链表头”
那就是另一道经典题“反转链表”了。实际上剑指 Offer 里专门有一道“反转链表”的题目，和这道题是“姊妹题”。如果你先做这道“从尾到头打印”，再做“反转链表”，会发现思路有很多重叠。建议刷题时把这两道放一起，对比着学习，效果事半功倍。
8.4 链表中点、环检测、合并有序链表等
这些都是链表专题的高频考点。当你把“从尾到头打印”的几种思路都吃透后，你对链表遍历、结点指针操作、辅助数据结构的使用会更得心应手，再做这些进阶题会更轻松。链表专题的核心能力无非三样：指针操作基本功、遍历与计数、以及借助额外结构（栈、队列、哈希表）来解决问题。
9. 完整的测试与运行指南
9.1 本地测试环境
推荐在本地用 GCC 或 Clang 编译测试。一个完整可运行的测试代码如下：
#include <stdio.h> #include <stdlib.h> struct ListNode { int val; struct ListNode *next; }; int* reversePrint(struct ListNode* head, int* returnSize) { struct ListNode* cur = head; int len = 0; while (cur) { len++; cur = cur->next; } if (len == 0) { *returnSize = 0; return NULL; } int* result = (int*)malloc(len * sizeof(int)); if (result == NULL) { *returnSize = 0; return NULL; } cur = head; int index = len - 1; while (cur) { result[index--] = cur->val; cur = cur->next; } *returnSize = len; return result; } struct ListNode* createList(int arr[], int n) { struct ListNode dummy; dummy.next = NULL; struct ListNode* tail = &dummy; for (int i = 0; i < n; i++) { struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode)); node->val = arr[i]; node->next = NULL; tail->next = node; tail = node; } return dummy.next; } void freeList(struct ListNode* head) { struct ListNode* cur = head; while (cur) { struct ListNode* next = cur->next; free(cur); cur = next; } } int main() { int arr1[] = {1, 3, 2}; int n1 = 3; struct ListNode* head1 = createList(arr1, n1); int size1 = 0; int* res1 = reversePrint(head1, &size1); printf("Test 1: "); for (int i = 0; i < size1; i++) { printf("%d ", res1[i]); } printf("\n"); free(res1); freeList(head1); struct ListNode* head2 = NULL; int size2 = 0; int* res2 = reversePrint(head2, &size2); printf("Test 2 (empty): size = %d\n", size2); free(res2); return 0; }把这段代码保存为reverse_print.c，编译运行：
gcc -Wall -Wextra -g reverse_print.c -o reverse_print ./reverse_print使用-Wall -Wextra开启编译警告，能帮你发现一些隐蔽的问题，比如未使用变量、类型不匹配等。-g 则是为了调试时保留符号信息，配合 GDB 可以快速定位段错误。
9.2 测试用例设计心得
除了题目给的[1,3,2]，我建议添加这些用例：
- 空链表
[]：验证返回空数组、returnSize 为 0。 - 单结点链表
[5]：验证长度为 1 时，数组只有一个元素。 - 两个结点
[1,2]：验证倒序逻辑是否正确。 - 大量结点的链表，比如一万个结点：验证递归方案会不会栈溢出（如果是显式栈方案则没问题）。
- 结点值包含负数、0、正数：防止输出格式问题。
每换一种解法，都拿这套用例跑一遍，能保证不同实现之间行为一致。这个过程看似简单，但对于养成严谨的工程习惯非常有帮助。我记得自己在刚刷题时，总觉得“题目过了就行”，后来在一个真实项目中因为没考虑空指针导致线上崩溃，才真正意识到边界测试的重要性。从那以后，不管多简单的题，我都会多写几个用例跑一遍。
9.3 如何对比三种解法的性能
如果你想在实际层面验证三种解法的差异，可以写一个简单的计时程序，对同一个大链表分别调用三种实现，用clock()函数统计耗时。通常反转法因为多了一次遍历，耗时最长；栈解法因为需要两次分配和一次复制，次之；两次遍历倒序填充最快。但这道题的链表长度在面试和刷题场景中通常不会大到让三种方案产生质变，所以复杂度分析才是更重要的评判标准。
10. 从这道题延伸出的学习建议
10.1 链表题目的“一题多解”训练法
我个人非常推荐“一题多解”的训练方法。同一个题目，今天用两次遍历、明天用栈、后天用递归、大后天用反转。每种解法都亲手实现一遍，而不是只看题解觉得“懂了”。这样训练下来，你对链表的理解深度会远超只刷三遍同一道题的“题数党”。
10.2 为每一道题建立“解题笔记”
在笔记本或博客上记录这道题的核心考点、你的解法、别人的解法、踩过的坑。比如“逆序输出类问题 -> 优先想到栈或递归；数组法能否随机访问决定是否有优化空间”。这些总结才是真正属于你的“剑指”。等面试前翻看自己的笔记，比重新刷一遍题效率高得多。
10.3 别忽视 C 语言本身的基础
最后想提醒的是：C 语言版本的刷题，核心难点往往不在“算法思路”，而在“内存管理”和“指针运用”。如果你发现自己总是卡在malloc、二级指针、结构体指针这些地方，说明你需要停下来回头补一补 C 语言基础。不是题目太难，是内功不够。我见过很多用 Python 刷题很顺的同学，转到 C 语言后连链表都不会创建，这中间的差距不是算法思维的差距，而是语言掌握的差距。
我个人在实际刷题中的体会是：“从尾到头打印链表”这道题，代码量不大，但它像一面镜子，能照出你对链表、栈、递归、内存管理这几个核心知识点的真实掌握程度。如果你能不看任何资料，独立写出两种以上解法，并清楚说出每种解法的时间和空间复杂度，那这道题才算真正过关。最后再分享一个小技巧：面试前把这道题的三种写法都默写一遍，顺带复习一下“反转链表”的迭代和递归两种写法，你会发现链表专题的底气一下子足了很多。
