反转链表。

核心回答

反转单链表，就是原地改变每个节点的 next 指向，再返回原尾节点作为新头。 用 prev 保存已反转部分的头，curr 指向待处理节点；每轮先保存原后继，再把 curr.next 指向 prev，最后推进指针。

结束时 curr=None，prev 就是新头。每个节点处理一次，时间 O(n)；迭代写法额外空间 O(1)，不需要新建节点或交换节点值。

迭代实现：先保住后继，再改方向

下面假设输入是以 None 结尾的普通无环单链表，使用 Python：

class ListNode:
    def __init__(self, val: int, next=None):
        self.val = val
        self.next = next


def reverse_list(head):
    prev = None
    curr = head
    while curr is not None:
        following = curr.next
        curr.next = prev
        prev = curr
        curr = following
    return prev

保存 following 的时机最关键。修改 curr.next 后，原来的向后连接已被覆盖；没事先保存后继，就无法沿原链表继续遍历。

以 1 → 2 → 3 → None 为例：

保存节点 2，令 1.next=None，已反转部分为 1 → None。
保存节点 3，令 2.next=1，已反转部分为 2 → 1 → None。
保存 None，令 3.next=2；随后 curr=None，返回节点 3。

始终是同一批节点，改变的是连接关系。单纯倒转节点值或复制新链表，也许得到相同值序列，却没有完成原地指针反转。

为什么不会丢节点

每轮开始时，prev 指向已反转前缀，curr 指向未处理后缀。保存后继后反转当前连接，再把当前节点并入前缀，就维持了这两个部分的边界。

空链表不进循环，返回 None；单节点处理一次后返回它自身，尾部仍指向 None。重复值也按节点连接处理，不按值查找或去重。

有环输入不满足这个前提，应先确认是否需要检测和处理环，不能把普通反转代码当作任意链表结构的修复方法。

递归也能写，但调用栈不是常数空间

先反转从第二个节点开始的子链表，再把当前节点接到它末尾：

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

子问题把 2 → 3 变成 3 → 2 后，head.next 仍指向节点 2。令 2.next=1，再令 1.next=None，得到完整结果。最后断开旧连接很重要，否则会保留 1 → 2 → 1 的环。

递归时间仍为 O(n)，调用栈深度为 O(n)。深链还可能超过 Python 解释器的递归深度限制，因此长链表优先用迭代版本。调高 sys.setrecursionlimit() 不会改变 O(n) 栈空间，限制设得过高还可能导致解释器崩溃。