实现一个函数，将给定的单向链表翻转，并返回翻转后的链表头节点。

示例：
输入：1 -> 2 -> 3 -> 4 -> 5
输出：5 -> 4 -> 3 -> 2 -> 1

答案：

import Foundation
class ListNode {
    var data: Int
    var next: ListNode?
    
    init(_ data: Int) {
        self.data = data
        self.next = nil
    }
}

func reverseList(_ head: ListNode?) -> ListNode? {
    var prev: ListNode? = nil
    var curr = head
    
    while curr != nil {
        let nextTemp = curr?.next
        curr?.next = prev
        prev = curr
        curr = nextTemp
    }
    
    return prev
}

// 创建一个包含5个节点的链表: 1 -> 2 -> 3 -> 4 -> 5
let node1 = ListNode(1)
let node2 = ListNode(2)
let node3 = ListNode(3)
let node4 = ListNode(4)
let node5 = ListNode(5)

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

// 打印原始链表的所有节点值
var node: ListNode? = node1
while node != nil {
    print(node!.data, terminator: " -> ")
    node = node!.next
}
print("nil")

// 反转链表并返回新的头节点
let newHead = reverseList(node1)
// 打印翻转后的链表的所有节点值
node = newHead
while node != nil {
    print(node!.data, terminator: " -> ")
    node = node!.next
}
print("nil")
//1 -> 2 -> 3 -> 4 -> 5 -> nil
//5 -> 4 -> 3 -> 2 -> 1 -> nil

知识点详解：

链表：链表是一种常见和重要的数据结构。更多见算法面试题05 - 链表中是否有环

链表反转又可以称为转置、翻转或逆置链表，将链表中的节点次序颠倒过来，即将链表的头节点变成尾节点，尾节点变成头节点，依次类推。

算法思路

1. 声明了两个指针变量 prev 和 curr，初始时将它们分别指向 nil 和链表的头节点 head。
2. 通过一个循环，遍历链表的所有节点。在每一轮迭代中，我们先用临时变量 nextTemp 保存当前节点 curr 的下一个节点，然后将当前节点的 next 指针指向前一个节点 prev，实现了翻转。
3. 更新 prev 和 curr 的位置，继续处理下一个节点，直到遍历完整个链表。
4. 返回翻转后的链表的头节点 prev。

复杂度分析

链表反转算法涉及遍历整个链表，因此时间复杂度为 O(n)，其中 n 是链表中节点的数量。在遍历链表时，需要定义三个指针变量 prev、curr 和 next，因此空间复杂度为 O(1)，与链表中节点的数量无关。

BTW

感谢各位简友的宝贵时间与意见！文章难免有疏漏或错误，如有涉及不当之处，还望能够提出宝贵意见。感激不尽！