---
title: 专为初中生设计的链表反转终极指南：图解迭代与递归两种核心解法，轻松攻克 LeetCode 经典题
created: 2026-03-16
updated: 2026-03-16
type: summary
tags: ["algorithm", "list", "notes", "recursion", "telegram"]
external: http://go/ui/posts/2188/
status: inbox
---

看到你在研究这道经典的链表题，作为初中生，能挑战 LeetCode 非常棒！这道题是学习链表和指针（在Python里是引用）操作的基础，很多同学一开始都会觉得它有点绕，但一旦掌握，后面的难题会轻松很多。别担心，我们一步步来。

### 🧠 第一步：理解什么是链表
在写代码前，得先明白我们要操作的对象是什么。你可以把**链表**想象成一列**寻宝火车**：
*   **车厢 (Node)**：每节车厢里装着两样东西：
    1.  **真正的物品 (Value)**：比如数字 `1`, `2`。
    2.  **指向下一节车厢的线索 (Next Pointer)**：告诉你下一节车厢在哪。
*   **火车头 (Head)**：指向第一节车厢的入口。
*   **反转链表**的任务，就是**让整列火车掉头**。原本的车尾变成新车头，所有车厢的连接方向完全反过来。

### 🔍 第二步：两种核心解法思路
题目要求你用两种方法实现，这里我用最生活化的方式给你解释。

#### **方法一：迭代法 (Iterative) - 像“排队改方向”**
想象你是一列火车（链表）的管理员，现在要让所有车厢掉头。你需要做三件事：
1.  **准备两个指针**：
    *   `prev` (之前)：指向已经掉好头的车厢。一开始还没开始，所以是 `None`。
    *   `curr` (当前)：指向你正要处理、准备让它掉头的车厢。一开始就是车头 `head`。
2.  **重复以下步骤，直到所有车厢处理完**：
    *   **第一步 (保存线索)**：`curr` 车厢上原本有指向下一节 `next` 车厢的线索。在改变它之前，先用一个临时变量 `temp` 把这个线索记下来，不然线索一改，后面的车厢就丢了。
    *   **第二步 (改变方向)**：让 `curr` 车厢的线索，不再指向原来的 `next`，而是指向已经掉好头的车厢 `prev`。**关键一步！**
    *   **第三步 (指针移动)**：现在 `curr` 车厢已经掉好头了。你往前走，准备处理下一节。怎么做？让 `prev` 移动到 `curr` 的位置，`curr` 移动到刚才保存好的 `temp` 的位置。
3.  **循环结束后**，`curr` 变成了 `None`（走到头了），而 `prev` 正好是最后一节车厢，也就是新的车头！返回 `prev`。

#### **方法二：递归法 (Recursive) - 像“洋葱剥皮”**
递归的核心思想是：**假设子问题已经解决了，我只需要把当前的问题接上去。**
1.  **想象你拿到一长串车厢**。你的任务是把整串反转。
2.  **你对自己说**：我不可能一下子搞定全部。但如果我把第一节车厢 `head` 后面的那串车厢 `head.next` 交给一个和我一样厉害的“魔法师”，让他帮我反转好，那我是不是就轻松了？
3.  **魔法师的工作**：他接过 `head.next` 这一串（从 `2` 到 `5`），并成功把它反转成了 `5->4->3->2`。他还告诉我，这串的新车头是 `5`。
4.  **你的最后一步**：现在，原来的 `head` 是 `1`，它后面原本是 `2`。但此时 `2` 已经是反转后那串的车尾了。你要做的，就是把 `1` 这节车厢，挂到车尾 `2` 的后面。也就是 `head.next.next = head`（让原来 `2` 指向的 `None` 变成指向 `1`）。最后，别忘了让 `1` 指向 `None`，它现在变成新车尾了。
5.  **魔法师的秘诀**：他和我用的是同样的方法。递归最关键的是要定义一个**终止条件**：如果火车是空的，或者只有一节车厢，那它本身就是反转后的结果，直接返回就行。

### 💻 第三步：用 Python 代码实现
下面就是这两种方法的具体代码，你可以试着运行一下，结合上面的比喻看注释，会更容易理解。

```python
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    # 方法一：迭代法 (Iterative)
    def reverseList_iterative(self, head: ListNode) -> ListNode:
        prev = None  # 一开始，前面没有车厢
        curr = head  # 从车头开始处理

        while curr:  # 只要还有车厢没处理
            temp = curr.next  # 1. 先保存好下一节车厢的线索，防止丢失
            curr.next = prev  # 2. 关键！让当前车厢掉头，指向前面那节
            prev = curr       # 3. 指针移动：prev 移到当前车厢
            curr = temp       # 4. 指针移动：curr 移到下一节车厢

        return prev  # 循环结束，prev 就是新车头

    # 方法二：递归法 (Recursive)
    def reverseList_recursive(self, head: ListNode) -> ListNode:
        # 递归终止条件：空链表 或 只有一个节点，反转后就是它自己
        if not head or not head.next:
            return head

        # 假设递归函数能把 head.next 之后的部分反转好，并返回新的头节点
        new_head = self.reverseList_recursive(head.next)

        # 此时，head.next 是原来下一节，现在它是反转后那部分的尾节点
        # 让这个尾节点指向当前的 head
        head.next.next = head
        # 当前的 head 变成尾节点，指向 None
        head.next = None

        return new_head  # 返回新的头节点
```

### 🚀 给你的学习建议
1.  **画图！画图！画图！**：在草稿纸上画出方框代表节点，用箭头代表 `next` 指针。按照代码一步步手动模拟指针的变化，这是攻克链表题最有效的方法。
2.  **先理解迭代**：迭代法的思路更贴近计算机实际的执行过程，逻辑直接，建议先掌握它。
3.  **再挑战递归**：递归代码很短，但思维跳跃。理解递归的关键是**相信递归函数能完成任务**，不要一层层在脑海里展开它，而是关注在**当前层**如何利用子问题的结果来构建最终答案。
4.  **关注边界条件**：多想想空链表 (`head = []`) 或只有一个节点的链表 (`head = [1]`) 时，你的代码能不能正确处理。

这道题是链表操作的地基，讨论区里也有不少同学分享类似的心路历程，坚持练习，你很快也能2分钟内写出来！等你完全掌握了反转，想试试把它用在更有趣的地方吗？比如**检查一个链表是否是回文结构**？那个题目就会用到反转链表的思想哦。
