LCR 024. 反转链表

题目：给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。

/**
 * 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) {
        // 1. 初始化三个指针
        ListNode prev = null;       // 指向当前节点的“前一个”节点，初始为 null
        ListNode curr = head;       // 指向“当前”正在处理的节点，初始为头节点

        // 2. 遍历链表，直到当前节点为 null（即遍历完所有节点）
        while (curr != null) {
            // 3. 关键步骤：保存当前节点的“后一个”节点
            ListNode nextTemp = curr.next; 

            // 4. 反转当前节点的指针：让它指向“前一个”节点
            curr.next = prev;

            // 5. 移动三个指针，准备处理下一个节点
            prev = curr;         // 前一个指针向后移动一步，指向当前节点
            curr = nextTemp;     // 当前指针向后移动一步，指向之前保存的下一个节点
        }

        // 6. 遍历结束后，prev 指向了原来的尾节点，也就是新链表的头节点
        return prev;
    }
}

步骤分解（以链表 1 -> 2 -> 3 -> null 为例）
初始状态:

• prev = null
• curr = 1 (head)
• 1 -> 2 -> 3 -> null

第一次循环 (curr = 1):

1. nextTemp = curr.next → nextTemp = 2

2. curr.next = prev → 1 -> null (反转 1 的指针)
3. prev = curr → prev = 1
4. curr = nextTemp → curr = 2

链表状态: null <- 1 , 2 -> 3 -> null

第二次循环 (curr = 2):

1. nextTemp = curr.next → nextTemp = 3
2. curr.next = prev → 2 -> 1 (反转 2 的指针)
3. prev = curr → prev = 2
4. curr = nextTemp → curr = 3

链表状态: null <- 1 <- 2 , 3 -> null

第三次循环 (curr = 3):

1. nextTemp = curr.next → nextTemp = null
2. curr.next = prev → 3 -> 2 (反转 3 的指针)
3. prev = curr → prev = 3
4. curr = nextTemp → curr = null

链表状态: null <- 1 <- 2 <- 3

循环结束 (curr = null):

• 此时，prev 指向 3，而 3 正是反转后链表的头节点。
• return prev，函数结束。

最终返回的链表就是 3 -> 2 -> 1 -> null

这里有个问题：

第一次循环 (curr = 1):
nextTemp = curr.next → nextTemp = 2
curr.next = prev → 1 -> null (反转 1 的指针)，为什么这里第一次循环是curr.next = prev → 1 -> null，prev是null，为什么能1->null？

即：其实是在问：prev 是 null，为什么执行 curr.next = prev 会让节点 1 指向 null？

解答

第一次循环时，prev 的值是 null

ListNode prev = null;  // prev 的值是 null
ListNode curr = head;  // curr 指向节点 1

所以 prev 的值是 null
执行 curr.next = prev; 就等同于：

curr.next = null;

null 在链表中的含义：
在链表中，null 表示 没有下一个节点，也就是链表的 末尾。
所以：

• 节点 1 的 next 原本指向节点 2
• 执行 curr.next = null; 后，节点 1 的 next 不再指向任何节点，表示节点 1 成为了链表的末尾