Reverse a singly linked list in Swift, iteratively and recursively. What can go wrong with long lists?

Predict first

What does the iterative and the recursive reversal print?

final class Node {
    var val: Int
    var next: Node?
    init(_ val: Int, _ next: Node? = nil) { self.val = val; self.next = next }
}
func reverse(_ head: Node?) -> Node? {
    var prev: Node? = nil, cur = head
    while let c = cur {
        let next = c.next          // remember the rest before overwriting the link
        c.next = prev
        prev = c
        cur = next
    }
    return prev
}
func reverseRecursive(_ head: Node?) -> Node? {
    guard let h = head, let n = h.next else { return head }
    let newHead = reverseRecursive(n)
    n.next = h
    h.next = nil
    return newHead
}
func list(_ a: [Int]) -> Node? { var h: Node? = nil; for v in a.reversed() { h = Node(v, h) }; return h }
func show(_ h: Node?) -> String {
    var out: [String] = [], c = h
    while let n = c { out.append(String(n.val)); c = n.next }
    return out.isEmpty ? "empty" : out.joined(separator: " -> ")
}
print(show(reverse(list([1, 2, 3, 4, 5]))))
print(show(reverse(list([7]))))
print(show(reverse(list([]))))
print(show(reverseRecursive(list([1, 2, 3]))))

• 5 -> 4 -> 3 -> 2 -> 1 / 7 / empty / 3 -> 2 -> 1
• 1 -> 2 -> 3 -> 4 -> 5 / 7 / empty / 3 -> 2 -> 1
• 5 -> 4 -> 3 -> 2 -> 1 / 7 / crash / 3 -> 2 -> 1