快慢指针法求链表中间结点：一次遍历搞定面试高频题

链表求中间结点，这题在面试里出现的频率相当高。它不偏不怪，属于"数据结构链表"基础中的基础，但恰恰是这种题最能看出一个人对指针操作和边界条件的掌握程度。我第一次在纸上写这题的时候，先数一遍长度、再走一半，代码写完后面试官问了一句：能不能只遍历一次？当时我愣了一下，后来才意识到，链表题里藏着的这套"快慢指针"思路，几乎贯穿了单链表一大半的高频题。这篇文章就把这道题讲透，从题目拆解、快慢指针原理、两种语言实现，到边界条件、常见误区和延伸应用，一次性聊清楚。

你如果是刚接触链表、准备笔试面试的在校生，或者工作中偶尔要手写链表的工程师，这篇都适合。看完你能独立把代码写对，还能举一反三，把快慢指针用到环形链表、找倒数第K个结点这些题上。

1. 题目拆解：先搞清楚要返回哪个"中间"

1.1 边界条件才是这题的第一道坎

题目本身不复杂：给定一个非空单链表的头结点 head，返回链表的中间结点；如果有两个中间结点，则返回第二个中间结点。这里有三个信息值得你停下来仔细品一品。

第一，"非空"链表。题目保证了输入不为空，但工程习惯上我还是建议你写判空处理。原因很简单：面试官可能换个问法，比如"如果链表为空呢"，你如果没想过这个分支，现场就容易慌。在 LeetCode 上虽然不会给你空链表，但养成判空的习惯没有坏处。第二，"第二个中间结点"。奇数长度比如 5 个结点，中间是第 3 个；偶数长度比如 4 个结点，中间有第 2 个和第 3 个，题目明确要求返回第 3 个，也就是偏右的那个。很多人第一次写就挂在这一点上，测试用例上一跑发现偶数长度结果不对，还以为是快慢指针写错了。第三，返回的是结点本身而不是结点的值。C 语言里要返回 ListNode *，Python 里要返回 ListNode 对象，别搞成返回 val。

这几个点看起来是"细枝末节"，但恰恰是链表题的难点所在。链表不像数组，没有 len() 方法直接拿长度，也不能下标随机访问，所有操作都只能靠遍历。所以"中间"这个概念，在链表上实现起来比数组要绕一些。

1.2 朴素解法：数两遍的笨办法

最直观的思路是这样的：第一遍遍历统计链表长度 n，第二遍从头走 n/2 步（整数除法），停下来的结点就是中间结点。为什么是 n/2 步而不是别的？你可以手动验证一下。

拿 5 个结点的链表举例，结点编号从 0 开始数：head 是第 0 个，走 1 步到第 1 个，走 2 步到第 2 个。5 个结点编号是 0、1、2、3、4，中间是第 2 个，所以走 5/2 = 2 步，正确。再拿 4 个结点举例，编号是 0、1、2、3，题目要求返回第二个中间结点，也就是第 2 个。4/2 = 2，走 2 步到第 2 个，也正确。所以 n/2 步这个结论对两种长度都成立。

代码写出来也很简单：

cpp复制int getLength(ListNode* head) {
    int len = 0;
    while (head != nullptr) {
        len++;
        head = head->next;
    }
    return len;
}

ListNode* middleNode(ListNode* head) {
    int n = getLength(head);
    for (int i = 0; i < n / 2; i++) {
        head = head->next;
    }
    return head;
}

这个解法的时间复杂度是 O(n)，空间复杂度是 O(1)，正确性也没有问题。但它要遍历两遍：第一遍数长度，第二遍找位置。如果链表特别长、或者这是一个只能读取一次的输入流，两遍遍历就可能成为性能瓶颈。

1.3 为什么值得换一种思路

有人可能会说，O(n) 已经是线性复杂度了，遍历两遍和遍历一遍不都是 O(n) 吗？从大 O 的角度确实一样，但实际场景里差别还是存在的。

举几个例子。如果这是一个流式数据，数据源只能读取一次，你根本没有机会重新回头遍历，那两遍遍历的方案直接就不可用。如果这个链表被封装在一个只允许单向遍历的接口后面，第一遍遍历完成后指针已经到末尾了，你没法再退回头结点，除非你提前存了 head 的副本——但即便是这样，你仍然需要从头再走一遍。在某些资源受限的嵌入式环境里，链表节点的访问可能要走总线、读寄存器，多一次全量遍历就多一份时间开销。另外我查资料时看到过"链表 芯片设计"这个组合词，在芯片验证、硬件描述语言里也有链表的影子，那种场景下对遍历次数往往更敏感，一次能解决的事情就不要做两次。

还有一个更实际的原因：快慢指针这个技巧本身是链表题里的"母题"。环形链表检测、寻找倒数第 K 个结点、链表归并排序、回文链表判断，全都建立在双指针的思想之上。你在中间结点这道题里把快慢指针吃透，后面那些题会轻松很多。所以换个思路不只是为了这题，是为了整个链表算法体系。

2. 快慢指针：一次遍历拿到中间结点的原理

2.1 核心思想就是"一倍速和两倍速"

快慢指针的思路一句话就能说清：两个指针同时从 head 出发，慢指针 slow 每次走一步，快指针 fast 每次走两步。当 fast 走到链表末尾时，slow 刚好停在中间位置。这就是两个人在跑步，一个速度是另一个的两倍，同时起跑，快的到终点时，慢的正好在半程。

为什么这个逻辑成立？你可以把链表看成一个一维的轨道，slow 的位移 s1 = t（每单位时间一步），fast 的位移 s2 = 2t（每单位时间两步）。当 fast 到达终点时，s2 = n（链表长度），此时 t = n/2，所以 slow 的位移 s1 = n/2。n/2 就是中间位置的下标，和朴素解法里第二遍走的步数完全一致。差别在于，朴素解法是"先知道 n 再走 n/2"，快慢指针是"让 fast 替 slow 数步数"，省掉了第一遍统计。

这里面有一个关键点需要理解：数组里我们用 a[n/2] 拿中间元素，是因为数组支持 O(1) 随机访问，下标本身就是位置信息。链表不行，链表只有 next 指针，位置信息必须靠遍历次数来累积。快慢指针的本质，就是利用速度差，把"长度的一半"这个信息隐式地编码在遍历过程中，slow 不需要知道 n 是多少，它只需要跟着 fast 走，自然停在该停的地方。这种"用速度换取信息"的思路，在算法里很常见。

理解这个类比之后，你要记住的其实是规律本身：快指针速度是慢指针的 2 倍，快指针到末尾时慢指针在中间。后面做环形链表检测时你会再次见到这个规律，只是判断条件从"fast 到末尾"变成了"fast 追上 slow"。

2.2 循环终止条件的设计逻辑

快慢指针的代码框架很简单，但循环条件写错的人不在少数。标准写法是：

cpp复制while (fast != nullptr && fast->next != nullptr) {
    slow = slow->next;
    fast = fast->next->next;
}

这个条件的含义是：只要 fast 当前不是空指针，且 fast 的下一个结点也不是空指针，就说明 fast 还能再往前走两步，循环继续。一旦 fast 为空，或者 fast->next 为空，就说明 fast 已经到达（或越过）链表末尾，没有更多步可走，循环终止，此时 slow 就是中间结点。

为什么是 && 不是 ||？你试一下就知道了。如果用 ||，意味着只要 fast 和 fast->next 有一个非空就继续循环。链表长度为 2 时，fast 在最后一个结点上，fast 非空、fast->next 为空，如果用 || 条件成立还会再走一次，fast 会直接变成空指针，slow 则会走到第 3 个结点——根本不存在的位置，结果就错了。所以必须是 &&：两个指针都非空才继续，保证 fast 每一步都落在一个合法结点上，同时这个结点还允许它再往前跨一步。

再往深一层说，这个条件其实精确地描述了快指针的移动能力。快指针每轮移动两步，它需要确保：第一步要落在合法结点上（fast != nullptr），第二步要落在合法结点上（fast->next != nullptr）。两步都合法才能移动，有一处不合法就停下。这个逻辑想清楚了，代码就不可能写错。

2.3 边界情况逐项推演

光看代码还不够，我建议你手动推演一遍全套边界情况，这也是我自己刷题时养成的习惯。你拿笔在纸上画一画，比看十遍题解都管用。

先看空链表的情况。fast 和 slow 都是空指针，while 条件里 fast != nullptr 不成立，循环不进入，直接返回 slow，也就是返回空指针。这个行为在某些题目变体里可能就是你要的结果，但注意题目如果保证非空，那这一步只是防御性写法。

再看只有一个结点的情况。head 指向唯一的结点，fast->next 是空，循环条件不成立，直接返回 slow，也就是 head 自己。一个结点的链表中间就是它自己，正确。

两个结点的情况，链表是 A -> B。fast 初始在 A，slow 在 A。循环条件成立（fast 非空且 fast->next 非空），执行一轮：slow 走到 B，fast 走两步——fast 先到 B，然后 fast->next 是空，fast 保持为指向 B 的指针。下一轮循环条件里 fast->next 为空，终止。此时 slow 在 B，也就是第二个结点。题目要求偶数长度返回第二个中间结点，正确。

三个结点的情况，A -> B -> C。第一轮：slow 到 B，fast 走两步到 C。此时 fast->next 为空，循环终止。slow 在 B，第 2 个结点，正是三个结点的中间，正确。

五个结点的情况，A -> B -> C -> D -> E。第一轮 slow 到 B、fast 到 C；第二轮 slow 到 C、fast 到 E；第三轮，fast 当前在 E，fast->next 为空，循环终止。slow 在 C，正是五个结点的中间，正确。

我建议你把每个 case 的指针移动过程在纸上画一遍，特别是长度为 2 和长度为 3 的 case，这两个最容易错。画完之后你会发现，这个循环条件的优雅之处在于：它不需要专门判断链表长度是奇数还是偶数，两种情况统一处理，代码只有一份。奇数时 fast 走到最后一个结点时停下，偶数时 fast 走到倒数第二个结点时停下，slow 都能落对位置。

3. C++ 和 Python 实现与编码细节

3.1 C++ 结构体指针版本

先用 C++ 写一遍。链表结点的标准定义如下：

cpp复制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) {}
};

这个定义是 LeetCode 默认的链表结点结构，构造函数分别对应"无参构造"、"传值构造"、"传值和 next 构造"三种方式。实际工程里你可以只保留 int val 和 ListNode* next，但刷题用这个定义最省事。

中间结点的函数：

cpp复制ListNode* middleNode(ListNode* head) {
    ListNode *slow = head;
    ListNode *fast = head;
    while (fast != nullptr && fast->next != nullptr) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

这段代码里有三个细节值得说一说。

第一，两个指针初始都指向 head，不是 slow 指向 head、fast 指向 head->next。有人看了一些变体题解，把 fast 初始化为 head->next，那是环形链表检测里的常见写法，和中间结点这题不一样。第二，循环体内先移动 slow 再移动 fast，这个顺序其实无所谓，因为两行代码互不依赖，但你最好每次写固定顺序，形成肌肉记忆，省得面试时临场乱。第三，返回值是 ListNode*，不是 int。我看到过有人写 return slow->val;，如果是测试代码可能没问题，但题目要求返回结点，后续如果需要用这个结点做操作（比如拆链表、反转后半段），返回结点才能继续链式操作。

3.2 Python 类对象版本

Python 的链表结点定义也很常规：

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

对应的中间结点函数：

python复制def middle_node(head: ListNode) -> ListNode:
    slow = head
    fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow

Python 版和 C++ 版逻辑完全一致，区别只在语法层面。fast and fast.next 依赖 Python 的短路求值：如果 fast 是 None，第一个条件为 False，整个表达式短路为 False，循环直接退出，根本不会去访问 fast.next，所以不会报空指针异常。这个行为和 C++ 的 fast != nullptr && fast->next != nullptr 是一模一样的。

Python 写链表题有一个优势：不用手动管理内存，也不用担心指针类型错误，写起来快。但也有一个劣势：Python 没有指针的概念，链表结点的连接关系靠对象引用模拟，有些人写着写着就把"node = node.next" 和 "node.next = something" 混在一起了。记住一点：node = node.next 是在"移动"，把当前指针挪到下一个结点；node.next = something 是在"修改连接"，改变当前结点的 next 指向。移动和修改是两码事，代码里别混。

另外 Python 里 next 是可以作为属性名的，但注意不要把它用作类名或函数名遮蔽掉内置函数 next()。如果你在同一个文件里又定义了 def next():，那 fast.next 就会出现奇怪的问题。这种坑虽然低级，但确实闷声出现过。

3.3 判断条件的顺序和空指针问题

这个点专门拿出来说，因为它真的是高频出错点。在 C/C++ 里，下面的写法看起来等价，但实际上是错的：

cpp复制// 错误示范
while (fast->next != nullptr && fast != nullptr) {
    // ...
}

问题在于 && 短路求值的顺序。C++ 里两个条件从左到右求值，fast->next 写在前面的意思是：先对 fast 解引用，取它的 next 字段。如果此时 fast 已经是 nullptr，对空指针解引用，程序直接崩溃，后面的 fast != nullptr 根本没有机会执行。正确的写法一定把 fast != nullptr 放在前面，先确认 fast 本身非空，再去访问 fast->next。

Python 里的对应写法是 while fast and fast.next:，同样把 fast 放在前面。这个顺序其实就是一句废话：判断一个指针非空才能访问它的成员。但就因为太基础，反而容易被人忽略，特别是在你改代码的时候把两个条件换了个位置。

我建议你在 C++ 里把循环条件固定记成"先 fast 后 fast->next"，每次写链表题都统一这个顺序。时间久了你会发现，空指针判断的顺序问题几乎贯穿所有链表操作，不只是这题。判空永远在解引用之前。

3.4 想要偏左的中间结点怎么办

前面说的是题目要求的"偶数长度返回第二个中间结点"，也就是偏右的那个。如果面试官换个问法："偶数长度返回第一个中间结点，怎么做？"其实只需要微调循环条件：

cpp复制ListNode* middleNodeLeft(ListNode* head) {
    ListNode *slow = head;
    ListNode *fast = head;
    while (fast->next != nullptr && fast->next->next != nullptr) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

注意这个写法里条件变成了 fast->next 和 fast->next->next，意思是：快指针能再走两步的条件，它的第一步和第二步都必须落在合法结点上。这与标准版的区别在于，标准版允许 fast 走到倒数第二个结点时再走最后一步（到达末尾的 nullptr），而偏左版不允许 fast 走到"倒数第二"这个位置，它要求 fast 至少还能再走两步，否则就停下。结果是，偶数长度时 slow 会停在第一个中间结点。

举例说明：链表 A -> B -> C -> D 四个结点。偏左版：第一轮 slow 到 B、fast 到 C；此时 fast->next 到 D 非空，但 fast->next->next 是空，条件不成立，循环终止。slow 停在 B，是第一个中间结点。4 个结点的中间位置是第 2 个和第 3 个，第一个中间是第 2 个（下标 1，即 B），正确。

这个变体在链表归并排序、回文链表判断里很常用，因为拆链表时你往往希望把链表均匀分成两半，前一半稍微偏左一点，后一半从 next 开始，两边长度差不超过 1。掌握了标准版和偏左版，你在做这些题时会少烧很多脑细胞。

4. 复杂度分析与常见误区排查

4.1 时间与空间复杂度为什么这么"漂亮"

快慢指针解法的时间复杂度是 O(n)，空间复杂度是 O(1)。这个结论怎么来的？先看时间：fast 指针每轮走两步，总共需要大约 n/2 轮循环，每轮循环里只做常数次操作（移动 slow、移动 fast、判断条件），所以总操作数是 n 的常数倍，复杂度 O(n)。注意，虽然 slow 只走了 n/2 步，但 fast 实际上把链表完整"扫描"了一遍，所以整体是 O(n) 而不是 O(n/2)——大 O 表示法里常数因子忽略不计，n/2 也是 O(n)。

空间复杂度更好算：只用了两个指针变量 slow 和 fast，没有申请任何与链表长度相关的额外内存，空间复杂度 O(1)。这也是这个解法比"用数组存链表再取中间"更优的地方。有的题解会先遍历一遍把结点全部塞进 vector 或 list，然后直接取 v[v.size()/2]，时间复杂度也是 O(n) 但空间是 O(n)，在大链表上内存开销不可忽视。快慢指针用 O(1) 的空间做到了同样的事情，这才是面试官想听到的答案。

我见过有人纠缠"快慢指针是不是遍历了两遍"，严格说不是。朴素解法是"慢速完整遍历 + 再走一半"，总共访问结点数约 1.5n 个；快慢指针解法中，fast 访问了一遍，slow 访问了半遍，总共访问结点数也是约 1.5n 个。从访问次数看二者差别不大，但快慢指针的好处是它"不需要知道 n"，这在只能遍历一次的场景下是本质区别。比如链表作为输入流存在，数据只能顺序读取不能回退，朴素解法直接失效，快慢指针却依然成立。

4.2 高频 bug：判空、移动顺序、返回值

链表题写错，绝大多数不是算法思路错，而是小细节没处理好。我把中间结点这题最常见的 bug 整理成一张速查表，你可以对照着检查自己的代码。

这几条里我要特别展开说一下"移动顺序错"这条。严格讲，在中间结点这题里，先移动 slow 还是先移动 fast 不影响最终结果，因为两个移动互不依赖。但有些扩展题里，顺序会影响正确性。比如在环形链表检测中，如果你写成先移动 fast 再移动 slow，在某些判断逻辑里会导致指针交错时漏判。所以我建议你从我这里开始，把"先 slow 后 fast"写成固定习惯，以后所有双指针链表题都用这个顺序，少给自己挖坑。

还有一个很多人会忽略的坑：修改链表结构时忘了保存 next。比如你在实现"链表插入"操作时，p->next = q 之前，如果 p 原来的 next 是你后面还要用的，就得先保存下来。中间结点这题不涉及修改结构，所以没有这个坑，但你在做逆序、删除等操作时一定要留意。链表题的 bug 往往不是逻辑层面的大错，而是这种"少了一行保存"的小失误。

4.3 误区：快指针步长一定得是 2 吗

这个问题的答案是：在中间结点场景下，快指针步长必须保证"快慢速度比是 2:1"。因为中间位置是 n/2，只有 fast 速度是 slow 的 2 倍时，fast 到达终点时 slow 才刚好在中点。

如果快指针每次走 3 步、慢指针每次走 1 步，那么当快指针到达末尾时，慢指针只走了 n/3 步，位置在链表前三分之一处，不是中间。如果快指针每次走 3 步、慢指针每次走 2 步，速度比是 3:2，快指针到达末尾时慢指针走了 2n/3，超过了一半。所以"快慢指针"的"快"和"慢"不是随便设定的，它们之间要有明确的比例关系，而这个比例由题目要求的"位置比例"决定。

有个类似的问题：如果链表长度未知，但又想找 1/3 位置处的结点，怎么做？思路一样，让快指针速度是慢指针的 3 倍，一个每次走 3 步，一个每次走 1 步，快指针到末尾时慢指针就在 n/3 处。这是一个很好的扩展思考题，你在面试时可以主动提出来，面试官会认为你对双指针的理解是真的到位了，而不是背了模板。

反向想一下：如果题目要求找倒数第 n 个结点，快慢指针还适用吗？适用，但不是"速度差"的思路，而是"固定间距"的思路。这个我们放到后面的扩展部分细说。你现在只要记住：双指针的核心不只是"一快一慢"，还有"一先一后"和"一左一右"，脑子里先把这几个模式建立起来。

5. 快慢指针方法论能带你去哪

5.1 环形链表检测：Floyd 判圈算法

快慢指针最经典的应用之一，就是判断链表是否有环，也就是 LeetCode 141 题。思路是：slow 每次走一步，fast 每次走两步，如果链表无环，fast 会先到达末尾（nullptr），循环正常结束；如果链表有环，fast 会在环里打转，最终追上 slow，两个指针相遇。这个算法叫 Floyd 判圈算法。

为什么 fast 一定能追上 slow？假设链表环的长度是 L，当 slow 进入环之后，fast 已经在环里了，二者相距的距离一定小于 L。fast 每轮比 slow 多走一步，也就是它们的相对距离每轮减少 1，经过最多 L 轮后，fast 必定追上 slow。这个"相对速度差"的思路和中间结点一脉相承，只是判断条件从"fast 到末尾"换成了"fast 追上 slow"。

写环形链表检测时注意一个陷阱：fast 初始位置。如果写成 slow = head; fast = head;，进入循环后在第一轮 slow 移动 1 步、fast 移动 2 步，如果链表只有一个结点且自环，循环条件 fast != nullptr && fast->next != nullptr 不成立（因为 fast->next 是 nullptr，虽然 fast 的 next 如果是自己则成立——这里要看具体建链方式）。为了更稳妥，很多写法是 slow = head; fast = head->next; 先让两者错开一步，再进入循环判断是否相遇。这属于实现的细节，你可以根据自己的习惯选择，但要知道两种写法在边界 case 下的差异。

5.2 寻找倒数第 K 个结点

找倒数第 K 个结点是双指针的另一种模式：固定间距。思路是：先让 fast 从头走 K 步，然后 slow 保持在 head，接着两个指针同步每次走一步。当 fast 走到末尾（nullptr）时，slow 恰好走到倒数第 K 个结点。

为什么成立？因为 fast 比 slow 始终领先 K 步。当 fast 到达末尾时，fast 一共走了"链表长度 n"的距离，而 slow 走了 n-K，所以 slow 的位置就是"从头数第 n-K 个结点"，也就是从尾部数第 K 个结点。这个思路和快慢指针不同，速度是相同的，但位置上有固定偏移。

如果你已经熟练掌握了中间结点的标准写法，这个题其实很简单：它只需要把循环条件改成 while (fast != nullptr)，循环体里 slow 和 fast 都走一步，只不过 fast 要提前走完 K 步的"起跑优势"。我见过不少人把这两个题搞混，一个用速度差，一个用位置差，但只要脑子里有一张"双指针模式图谱"，区分起来并不难。图谱就三条：速度差（找中间、判环）、位置差（倒数第 K 个）、左右夹逼（有序数组两数之和，这个偏数组场景）。

5.3 链表的归并排序：找中点是分治的第一步

链表排序的最佳选择通常是归并排序，因为链表不支持 O(1) 随机访问，快速排序的 partition 操作在链表上实现起来别扭。而归并排序的核心操作就是"把链表从中间拆成两半"，这一步正需要快慢指针。

具体来说：先用快慢指针找到链表的中间结点（标准版返回偏右的那个，或者用偏左版返回第一个中间结点），然后把 slow 前面的结点 next 断掉，链表就被拆成了左右两条子链。对左右子链分别递归排序，最后做一个有序链表的合并。这里的"找中间"只是第一步，但它是整个算法的地基，地基打不好，递归分治全乱。

cpp复制ListNode* sortList(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return head;
    }
    ListNode *slow = head, *fast = head, *prev = nullptr;
    while (fast != nullptr && fast->next != nullptr) {
        prev = slow;
        slow = slow->next;
        fast = fast->next->next;
    }
    prev->next = nullptr;  // 断开前半段
    ListNode* left = sortList(head);
    ListNode* right = sortList(slow);
    return mergeTwoLists(left, right);
}

这个代码里 prev 的作用就是记录 slow 的前一个结点，为断链做准备。你会发现，如果不加 prev，你就没法把前半段的末尾置为空指针，链表就没法真正拆开。这种"在快慢指针基础上再加一个 prev 记录前驱"的写法，是你掌握标准版之后自然延伸出来的能力。

回文链表判断也是同样的套路：先用快慢指针找到中间，然后把后半段反转（这就是"python 单链表逆序"、链表逆序相关操作在实战中的典型应用），再逐一比较前半段和后半段的值。找到中间是这个流程的第一环，后续所有操作都依赖这个"锚点"。

5.4 从中间结点到链表操作的整体能力

中间结点这题练完之后，你其实应该借机把链表的核心操作全部过一遍。我提几个必练的点，每个都是面试高频：单链表的创建和遍历（对应热词里的"链表遍历""单链表的基本操作实验"）；在指定位置插入结点（"链表插入"）；删除指定结点；反转整个链表（三指针迭代法，对应"python 单链表逆序"）；找到中间结点（本文内容）；检测环；合并两个有序链表；找两个链表的交点。这些操作看起来多，但本质上都是对 next 指针的读写，练多了就会发现规律。

链表结构在 C 语言里叫法很朴素，就是 struct ListNode，C++ 里可以写成类或结构体，这个基础语法点很多人觉得太简单不屑于复习，实际上写快慢指针时连 ListNode* 的前缀都打错的人，我见过不止一个。"c++ 结构体链表基本语法"这种基础词如果搜出来的内容你全都能秒懂，说明基本功是过关的。

我有一次在梳理练习清单时，把链表相关的东西按难度排了个序：基本操作（建、插、删、遍历） → 中间结点/倒数第 K 个（双指针入门） → 反转/逆序（三指针/递归） → 环检测（快慢指针进阶） → 归并排序/回文判断（综合应用）。按这个顺序练，每一层都站在上一层的肩膀上，进步会快很多。

6. 实操心得与刷题建议

6.1 链表题怎么练才扎实

我自己练链表题的经验是：只看题解写一遍远远不够，一定要做到"三遍法"。第一遍，照着题解完整写一遍，理解和记忆代码；第二遍，合上题解，只看着题目自己写，写完对照；第三遍，过两天再回来写，要求一次写对，没有任何调试。三遍法听起来笨，但比你刷十道新题都有用，因为链表题的正确率靠的是"对指针操作的绝对准确"，这个只能靠反复输出建立肌肉记忆。

中间结点这题值得你额外多做一样事：把链表长度从 0 到 6 的所有边界情况在纸上推演一遍，每个 case 都写出 fast 和 slow 的移动轨迹。等你闭着眼都能说清楚长度为 4 时 slow 停在哪、长度为 5 时 fast 停在哪个位置，这个题才算真的吃透了。

说到"链表遍历"，它和数组遍历最大的区别在于：数组遍历可以用下标控制循环次数，链表遍历只能靠"下一个是否为空"来判断。很多刚从数组思维转过来的人，写链表遍历时总想"记录一下走了几步"，但链表没有一个 O(1) 方法拿到长度，这是一个思维模式的转变。你接受"必须遍历才能知道长度"这个事实之后，再看到快慢指针这种"不需要知道长度也能找到中点"的方案，会格外觉得设计精妙。

6.2 面试场上怎么把这个题答漂亮

面试时遇到这题，我建议你这样组织回答，这条路径我实测有效。

第一步，先说朴素方案。面试官要考察的不仅是你会不会最优解，还包括你能否从最直接的思路开始逐步优化。你说"我可以先遍历一遍数长度，再走 n/2 步找中间"，这个答案本身没错，复杂度 O(n) 时间 O(1) 空间。把这段讲清楚，面试官就知道你对基础方法有把握。

第二步，主动提出优化。你说"但上述方法要遍历两遍，如果链表只能遍历一次，或者长度很大，两遍开销明显；实际上可以用快慢指针，快指针每轮走两步、慢指针走一步，快指针到末尾时慢指针正好在中间"。这段话的亮点是给了"为什么"——不是为了炫技，而是为了解决两遍遍历的痛点。

第三步，主动说边界。你不要等面试官问空链表怎么办，自己就讲出来："如果链表为空，直接返回空；如果只有一个结点，返回头结点；偶数长度时题目要求返回第二个中间结点，我的循环条件保证了这个行为。"主动讲边界是加分的，因为它体现的是工程思维，不是只背代码。

第四步，把代码写在白板或共享文档上。注意变量名用 slow、fast，不要用 p、q 这种没有语义的名字；注意判空顺序；注意最后返回 slow 而不是 slow->val。写代码的过程不要沉默，可以边写边简单解释这一步在做什么。写完之后不要再改来改去，特别是不要在面试官面前反复调试同一个错误，那会显得对代码没有掌控力。

6.3 一个体会：顺序表与链表之争

聊到链表题，免不了被问到"什么时候用链表，什么时候用数组/顺序表"。这个问题的标准答案大家都知道：随机访问频繁用数组，插入删除频繁用链表。但工程里真正的选择往往更复杂。

顺序表的优势是内存连续、缓存友好，遍历起来快；劣势是插入删除要搬移元素，扩容代价高。链表则相反，插入删除只要改指针，但每个结点要额外存一个 next 指针，内存开销大，而且结点在内存中可能分散，缓存命中率低。热词里有"顺序表和链表"，说明很多人在这两者之间纠结过。我给一个朴素的建议：数据规模小、操作以访问为主，用顺序表；数据规模大、操作以插入删除为主、且不需要随机访问，用链表。注意"不需要随机访问"这个前提很关键，如果既要频繁随机访问又要频繁插入，那数组加索引或平衡树可能比链表更合适。

链表在底层软件里的应用其实比你想的多。操作系统内核里很多链表结构用于管理进程、内存块；嵌入式设备里会有侵入式链表节省内存；就连"链表 芯片设计"这种看起来偏硬的方向，也有链路管理、片上网络资源管理的场景。所以别觉得链表题是面试八股，它背后对应的是真实系统里"动态、无序、频繁变更"的数据管理需求。

最后再分享一个小技巧。我个人在实际操作中写链表题，有个习惯：先从最简单的"返回头结点"开始推演，再往外推一层。比如中间结点这题，我会先想一个结点时返回什么、两个结点时返回什么，找到规律后再对照循环条件检查。这个习惯帮我避开了九成以上的边界 bug。你也试试，在纸上把链表画成方框和箭头，把快慢指针想象成两个箭头在移动，很多看似抽象的东西一下子就具体了。链表本身就是一连串 next 指针把人往下一个节点带，你用箭头的方式理解它，比背代码靠谱得多。