LeetCode递归实战：从斐波那契到链表反转，5个经典案例带你彻底搞懂递归

关注

原创最新推荐文章于 2026-04-18 15:43:31 发布 155 阅读 AI 写同款· GEO 优化 ›

LeetCode递归实战：从斐波那契到链表反转，5个经典案例带你彻底搞懂递归

第一次接触递归时，很多人会被它那种"自我调用"的特性所迷惑——一个函数居然可以调用自己？这不会导致无限循环吗？直到我在LeetCode上刷到第50题时，才真正体会到递归的优雅与强大。记得当时为了理解汉诺塔问题的递归解法，我在白板上画了整整三页的调用栈示意图。本文将带你用五个经典案例，从基础到进阶，逐步拆解递归的思维模型。

1. 递归基础：斐波那契数列的启示

斐波那契数列是理解递归最经典的入门案例。这个数列的定义本身就带有递归特性：F(0)=0，F(1)=1，当n>1时，F(n)=F(n-1)+F(n-2)。这种"用自身定义自身"的特性，正是递归算法的天然应用场景。

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

这个简洁的实现完美诠释了递归三要素：

基准条件：当n≤1时直接返回n
递归调用：分解为fib(n-1)和fib(n-2)
组合结果：将子问题结果相加

但这段代码存在严重的性能问题——重复计算。以计算fib(5)为例：

fib(5)
├── fib(4)
│   ├── fib(3)
│   │   ├── fib(2)
│   │   │   ├── fib(1)
│   │   │   └── fib(0)
│   │   └── fib(1)
│   └── fib(2)
│       ├── fib(1)
│       └── fib(0)
└── fib(3)
    ├── fib(2)
    │   ├── fib(1)
    │   └── fib(0)
    └── fib(1)

提示：实际面试中，纯递归解法通常不是最优解，但理解这个原始版本对掌握递归思维至关重要。

2. 递归优化：记忆化与迭代转化

为了避免重复计算，我们可以引入**记忆化(Memoization)**技术。这是一种典型的"以空间换时间"策略：

memo = {0:0, 1:1}
def fib_memo(n):
    if n not in memo:
        memo[n] = fib_memo(n-1) + fib_memo(n-2)
    return memo[n]

这个优化版本的时间复杂度从O(2^n)降到了O(n)，但空间复杂度升为O(n)。对于斐波那契数列，我们还可以进一步优化为迭代版本：

def fib_iter(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(2, n+1):
        a, b = b, a + b
    return b

三种实现方式的性能对比：

方法类型	时间复杂度	空间复杂度	LeetCode执行时间
纯递归	O(2^n)	O(n)	>1000ms
记忆化	O(n)	O(n)	32ms
迭代	O(n)	O(1)	28ms

3. 递归进阶：链表反转的艺术

链表反转是递归应用的另一个经典场景。相比迭代法需要维护三个指针，递归解法展现出惊人的简洁性：

def reverseList(head):
    if not head or not head.next:
        return head
    new_head = reverseList(head.next)
    head.next.next = head  # 关键步骤：让下一个节点指向自己
    head.next = None       # 断开原有连接
    return new_head

理解这段代码的关键在于想象递归栈的展开过程。假设链表为1→2→3→4→5：

递归到最深层时遇到节点5，满足基准条件直接返回
回到节点4的上下文，此时head=4，head.next=5
- 执行head.next.next=head即5.next=4
- 设置4.next=None断开原有连接
同理处理节点3、2、1
最终new_head始终指向原始链表的尾节点5

注意：链表类问题的递归解法通常需要更多的栈空间，对于超长链表可能导致栈溢出。

4. 递归实战：两两交换链表节点

LeetCode第24题要求两两交换链表中的节点，这比单纯反转更具挑战性。递归解法依然展现出清晰的逻辑结构：

def swapPairs(head):
    if not head or not head.next:
        return head
    first = head
    second = head.next
    first.next = swapPairs(second.next)  # 递归处理剩余部分
    second.next = first                  # 完成当前交换
    return second                        # 返回新的头节点

这个案例展示了递归处理局部结构+连接后续结果的典型模式。关键步骤解析：

保存当前节点和下一节点引用
当前节点的next指向递归处理后的剩余链表
下一节点的next指向当前节点
返回新的头节点(原第二个节点)

可视化过程（链表A→B→C→D）：

swapPairs(A)
├── A.next = swapPairs(C)
│   ├── C.next = swapPairs(null) → return D
│   └── D.next = C → return D
└── B.next = A → return B
最终结果：B→A→D→C

5. 递归高阶：合并K个有序链表

当问题升级到合并K个有序链表时，递归结合分治策略展现出强大威力。这个问题是LeetCode上的困难题型，但递归解法依然保持优雅：

def mergeKLists(lists):
    if not lists:
        return None
    if len(lists) == 1:
        return lists[0]
    
    mid = len(lists) // 2
    left = mergeKLists(lists[:mid])    # 递归处理左半部分
    right = mergeKLists(lists[mid:])   # 递归处理右半部分
    return mergeTwoLists(left, right)  # 合并两个有序链表

def mergeTwoLists(l1, l2):
    if not l1:
        return l2
    if not l2:
        return l1
    if l1.val < l2.val:
        l1.next = mergeTwoLists(l1.next, l2)
        return l1
    else:
        l2.next = mergeTwoLists(l1, l2.next)
        return l2

这种分治策略的时间复杂度为O(NlogK)，其中N是总节点数，K是链表数量。相比顺序合并的O(NK)有显著提升。算法流程解析：