代码随想录算法训练营第三天 | (第二章) 206. 反转链表

题目 (LeetCode)

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

---

Python小知识

递归法

递归法是一种编程技术，函数通过直接或间接调用自身来解决问题。递归将问题分解为更小的子问题，并通过递归调用逐步解决这些子问题，直到满足特定的基准条件后终止递归。

递归法的两大关键要素：

1. 基准条件（Base Case）：
   • 明确递归的终止条件。
   • 当满足条件时，不再进行递归调用，而是直接返回结果。
2. 递归关系（Recursive Case）：
   • 将原问题分解为一个或多个规模更小的子问题。
   • 通过递归调用自身来解决这些子问题。

递归法的工作原理

1. 递归深入阶段：
   • 函数被多次调用，不断分解问题，直到满足基准条件。
2. 回溯阶段：
   • 每一层调用返回时，根据递归关系将结果组合起来，逐层返回到最初的调用。

举例：计算阶乘

def factorial(n):
    if n == 0 or n == 1:  # 基准条件
        return 1
    return n * factorial(n - 1)  # 递归关系

计算 factorial(5) 的执行过程：

1. 递归深入：
   • factorial(5) 调用 factorial(4)
   • factorial(4) 调用 factorial(3)
   • factorial(3) 调用 factorial(2)
   • factorial(2) 调用 factorial(1)
   • factorial(1) 满足基准条件，返回 1。
2. 回溯阶段：
   • factorial(2) 返回 2 * 1 = 2
   • factorial(3) 返回 3 * 2 = 6
   • factorial(4) 返回 4 * 6 = 24
   • factorial(5) 返回 5 * 24 = 120

最终结果为 120。

---

Python代码

方法 1：迭代法

通过逐步改变每个节点的 next 指针方向来反转链表。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None  # 前驱节点，初始为 None
    	current = head  # 当前节点，初始为 head

    	while current:  # 遍历整个链表
	        next_node = current.next  # 暂存当前节点的下一节点
	        current.next = prev  # 反转当前节点的指针
	        prev = current  # 移动前驱指针
	        current = next_node  # 移动当前指针

    	return prev  # 返回反转后的新头节点

方法 2：递归法

递归地反转链表，将问题分解为更小的子问题。

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  # 将下一个节点的 next 指向当前节点
        head.next = None  # 当前节点的 next 设为 None，断开连接
        
        return new_head  # 返回新的头节点

核心理解： 递归深度和返回的顺序

首先要明确，递归函数的调用是一个“先深入后返回”的过程。在我们调用 reverseList(1) 时，它首先会递归调用 reverseList(2)，然后是 reverseList(3)，依此类推，直到递归到链表的最后一个节点。当递归函数开始返回时，才会依次执行反转当前节点的操作。

深入到最底层：reverseList(5)

当递归到最底层，即链表的最后一个节点 5 时，递归返回。此时的 head 是指向节点 5 的，我们没有进行任何反转，因为 head.next 是 None，即没有后续节点。

然后开始返回的过程中反转链表：

在每一层的返回过程中，反转操作逐层执行，这就是为什么在 reverseList(1) 中你没有看到立即执行反转操作的原因。每一层递归会等到下一层完全执行完毕后，才会开始处理当前的节点。

具体步骤分析

假设我们的链表是：1 -> 2 -> 3 -> 4 -> 5 -> None。

1. reverseList(5)：

递归终止条件，返回 5：

return head  # head = 5

此时链表依然是：5 -> None。

2. reverseList(4)：

• 递归返回值：new_head = 5
• 反转当前节点 4：

head.next.next = head  # 5.next = 4
head.next = None  # 4.next = None

• 当前链表变为：5 -> 4 -> None
• 返回 new_head = 5。

3. reverseList(3)：
• 递归返回值：new_head = 5
• 反转当前节点 3：

head.next.next = head  # 4.next = 3
head.next = None  # 3.next = None

• 当前链表变为：5 -> 4 -> 3 -> None
• 返回 new_head = 5。

4. reverseList(2)：
• 递归返回值：new_head = 5
• 反转当前节点 2：

head.next.next = head  # 3.next = 2
head.next = None  # 2.next = None

• 当前链表变为：5 -> 4 -> 3 -> 2 -> None
• 返回 new_head = 5。

5. reverseList(1)：
• 递归返回值：new_head = 5
• 反转当前节点 1：

head.next.next = head  # 2.next = 1
head.next = None  # 1.next = None

• 当前链表变为：5 -> 4 -> 3 -> 2 -> 1 -> None
• 返回 new_head = 5，这是最终的反转后的链表头。

为什么在最初调用 reverseList(1) 时没有立即执行 head.next.next = head？

这是因为递归的方式：我们在递归过程中逐层深入，直到到达链表的末尾。在每一层递归中，我们仅是“传递”了链表的头部，并没有立即改变当前节点的指向。只有当递归逐层返回时，我们才开始执行 head.next.next = head 和 head.next = None 这样的操作，从而一步一步地反转链表。

具体来说：
• 递归深度：当你调用 reverseList(1) 时，实际上是先调用了 reverseList(2)，然后是 reverseList(3)，依此类推，直到调用 reverseList(5)。直到递归调用栈回溯到 reverseList(5)，才开始执行反转操作。
• 递归返回时的顺序：每一层递归会先处理链表的下一个节点，直到递归到链表的最后一个节点。然后在返回的过程中，每一层逐步反转链表的指向，最终实现整个链表的反转。

总结：head.next.next = head 这种操作的执行时机是在递归返回时，而不是递归深入时。递归深入时，我们只是将控制权传递给下一个节点。只有在递归回溯时，才会逐层反转节点的指向，从而最终反转整个链表。

---

两种方法比较

方法	时间复杂度	时间复杂
迭代	O(n)	O(1)
递归	O(n)	O(n)（递归栈空间）

如果链表较长，迭代法更高效，因为递归法可能导致栈溢出。