Python实现链表反转：迭代与递归双解法详解

目录

一、问题描述

二、核心代码实现

2.1 迭代法实现

迭代法中的prev初始值是None的原因：

关键步骤图解

2.2 递归法实现

递归法中要设置head.next = None的原因

递归过程拆解

三、方法对比与选择建议

---

 

一、问题描述

链表反转是数据结构中的基础算法问题，常见于面试和算法题库（如LeetCode #206）。要求将单向链表的节点顺序完全倒置

二、核心代码实现

2.1 迭代法实现

时间复杂度：O(n)
空间复杂度：O(1)

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None
        current = head
        
        while current:
            next_node = current.next  # 暂存下一节点
            current.next = prev       # 反转指针方向
            prev = current            # 前驱指针后移
            current = next_node       # 当前指针后移
        
        return prev                   # 返回新头节点

迭代法中的prev初始值是None的原因：

• 保证反转后的链表末尾指向None，符合单向链表定义。

关键步骤图解

以链表 1 -> 2 -> 3 ->4 ->5 -> None 为例

初始状态： 1   ->   2   ->   3   ->   4   ->   5  
                current

第1次循环：
        暂存下一节点:next_node = current.next 
               1      ->      2      ->      3      ->      4      ->      5
          current     next_node
        反转指针方向:current.next = prev
            None     <-     1                  2      ->      3      ->      4      ->      5
            pre             current       next_node
        前驱指针后移:prev = current   
            None     <-         1                   2      ->      3      ->      4      ->      5
                                  current       next_node
                                    pre
        当前指针后移:current = next_node
            None         <-         1                 2      ->      3      ->      4      ->      5     
                                        pre          next_node
                                                         current

第2次循环后：None <- 1 <- 2  3 -> 4 -> 5  
...
最终结果：5 -> 4 -> 3 -> 2 -> 1 -> None

2.2 递归法实现

时间复杂度：O(n)
空间复杂度：O(n)（递归栈深度）

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 递归终止条件：空节点或单节点
        if not head or not head.next:
            return head
        
        # 递归到链表末尾
        new_head = self.reverseList(head.next)
        
        # 反转指针方向
        head.next.next = head  # 后一节点指向前一节点
        head.next = None       # 断开原方向
        
        return new_head

递归法中要设置head.next = None的原因：

• 防止形成循环链表。例如在反转节点1时，若不置空，1仍指向2，而2已指向1，导致1↔2循环。

递归过程拆解

以链表 1 -> 2 -> 3 -> None 为例：

递归层级 3：返回节点3（head=3）
递归层级 2：处理节点2，执行 2.next.next=2 → 3->2，2.next=None → 3->2->None
递归层级 1：处理节点1，执行 1.next.next=1 → 2->1，1.next=None → 3->2->1->None
最终返回 new_head=3

三、方法对比与选择建议

方法对比：

对比项	迭代法	递归法
时间复杂度	O(n)	O(n)
空间复杂度	O(1)	O(n)（栈空间）
代码简洁性	中等	简洁
适用场景	长链表、内存敏感环境	短链表、代码简洁性优先
可读性	直观易理解	需理解递归栈

选择建议：

• 优先选择 迭代法：适合处理长链表，避免栈溢出风险。

• 可考虑 递归法：代码简洁，但需注意链表长度限制（Python默认递归深度≤1000）。

 注意：若链表包含虚拟头节点（Dummy Head），需调整链表反转的起始位置