【Leetcode】剑指Offer 24：反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
限制：
0 <= 节点个数 <= 5000
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

AC代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head == None:
            return None
        if head.next == None:
            return head
        if head.next.next == None:
            res = head.next
            head.next = None
            res.next = head
            return res
        
        prior = head
        letter = head.next
        prior.next = None

        while letter != None:
            temp = letter.next
            letter.next = prior
            prior = letter
            letter = temp
        
        return prior

这段时间的题目都能用双指针处理，这题方法是存下原先的子节点，然后让前后节点挪到断裂的链表位置进行修复，再利用临时存储进行位移，一路修复就好了。

妙解

class Solution:
    def reverseList(self, head):
        preNode = None
        currNode = head
        while currNode:
            nextNode = currNode.next
            currNode.next = preNode
            preNode = currNode
            currNode = nextNode
        return preNode

事实上，最开始做的时候存在一些小的问题，为了AC就直接把前面的一些特殊情况先做了处理。其实只要把prior从None开始数起就可以把之前进行单独讨论的结果合并到同样的公式中了。

递归解法

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        def recur(cur, pre):
            if not cur: return pre     # 终止条件
            res = recur(cur.next, cur) # 递归后继节点
            cur.next = pre             # 修改节点引用指向
            return res                 # 返回反转链表的头节点
        
        return recur(head, None)       # 调用递归并返回

作者：jyd
链接：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/solution/jian-zhi-offer-24-fan-zhuan-lian-biao-die-dai-di-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这个递归解法其实可读性不如迭代，而且本质是相同的，这个方法由于会有很多的栈所以效率应该不如直接迭代。