【力扣热题100】—— Day3.反转链表

你不会永远顺遂，更不会一直年轻，你太安静了，是时候出发了

------ 24.12.2

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

方法一 双指针迭代

定义两个指针pre、temp，pre指针指向null，然后将给出的链表从头节点head进行遍历，先将temp指针指向head.next节点，将遇到的节点head的next指向置为pre指针：head.next = pre，（pre指针指向空值，第一次迭代则将原链表最后一个元素作为翻转后的链表的第一个元素），然后再将head指针的指向修改回先前存储的temp指针处，将整个原链表遍历完成，则对链表翻转完成

---

Java实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        while(head != null) {
            ListNode tmp = head.next; // 暂存后继节点 head.next
            head.next = pre;          // 修改 next 引用指向
            pre = head;               // pre 暂存 head
            head = tmp;               // head 访问下一节点
        }
        return pre;
    }
}

---

Python实现

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur, pre = head, None
        while head:
            # 1.将头结点的下一个节点暂存在temp中
            temp = cur.next
            # 2.头结点的下一个节点存入pre指针中
            cur.next = pre
            # 3.pre指针指向头结点，即pre指针永远指向新链表添加节点的位置，而新节点一直随着头结点更新而更新
            pre = cur
            # 4.将头结点指向一开始存入的下一个节点，起到遍历的作用
            cur = temp
        # 返回构造的翻转后的新链表
        return pre

---

方法二 递归

考虑使用递归法遍历链表，当越过尾节点后终止递归，在回溯时修改各节点的next引用指向。

递归函数:recur(cur,pre)

**1.终止条件:**当 cur 为空，则返回尾节点pre(即反转链表的头节点)

2.递归后继节点，记录返回值(即反转链表的头节点)，为res

3.修改当前节点 cur 引用指向前驱节点 pre;

4.返回反转链表的头节点 res

reverseList(head)函数：

调用并返回recur(head，null)。

传入null是因为反转链表后，head节点指向 null;

---

Java实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        return recur(head, null);    // 调用递归并返回
    }
    
    private ListNode recur(ListNode cur, ListNode pre) {
        if (cur == null){
            return pre; // 终止条件
        }
        ListNode res = recur(cur.next, cur);  // 递归后继节点
        cur.next = pre;              // 修改节点引用指向
        return res;                  // 返回反转链表的头节点
    }
}

---

Python实现

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
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)       # 调用递归并返回