为何类函数比嵌套子函数更快？以LeetCode反转链表题为例

两种解法的核心逻辑完全一致，但在LeetCode上解法1（类成员函数实现递归）的执行速度始终优于解法2（嵌套函数实现递归），主要原因在于Swift对这两种函数的底层处理和优化差异：

• 嵌套函数的上下文捕获开销：解法2中的recurse是嵌套在reverseList内部的函数，尽管它直接访问的是类的prev属性，但Swift的嵌套函数会隐式关联外部函数的上下文。每次递归调用嵌套函数时，都需要处理上下文的引用逻辑，这会产生微小但可累计的额外开销，当链表节点数量较多时，这个开销会被明显放大。

• 函数调用的直接性差异：解法1的recurse是类的成员函数，它直接绑定在类实例上，调用时的地址寻址更直接。Swift编译器可以对这类函数做更多激进优化，比如直接的函数地址跳转、内联优化等。而嵌套函数依赖外部函数的上下文，每次进入reverseList时才会生成嵌套函数的实例，调用时需要多一层间接寻址，增加了调用成本。

• 编译器优化空间的不同：类成员函数的依赖关系更清晰，编译器更容易识别并消除冗余操作；而嵌套函数因为和外部函数的上下文绑定，优化空间相对受限，无法完全消除上下文关联带来的额外开销。

解法1（类成员函数版） #

class Solution {
    var prev: ListNode? = nil
    func reverseList(_ head: ListNode?) -> ListNode? {
        recurse(head)
        return prev
    }
    func recurse(_ node: ListNode?){
        guard let current = node else { return }
        let next = current.next
        current.next = prev
        prev = current
        recurse(next)
    }
}

解法2（嵌套函数版） #

class Solution {
    var prev: ListNode? = nil
    func reverseList(_ head: ListNode?) -> ListNode? {
        func recurse(_ node: ListNode?){
            guard let current = node else { return }
            let next = current.next
            current.next = prev
            prev = current
            recurse(next)
        }
        recurse(head)
        return prev
    }
}

内容的提问来源于stack exchange，提问作者brunshte