hot 100 第二十四题 24.回文链表

题目：

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

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

示例 2：

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

核心思路

快慢指针 + 反转后半部分 + 比较

步骤：

1. 用快慢指针找到链表中点

2. 反转后半部分链表

3. 比较前半部分和反转后的后半部分

4. （可选）恢复链表

   原链表: 1 → 2 → 2 → 1

   步骤1: 找中点
   1 → 2 → 2 → 1
   ↑
   中点

   步骤2: 反转后半部分
   前半: 1 → 2
   后半: 1 → 2 (反转后)

   步骤3: 比较
   1 == 1 ✓
   2 == 2 ✓
   是回文

题解：

class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) return true;
        
        // 1. 用快慢指针找到中点
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        
        // 2. 反转后半部分
        ListNode secondHalf = reverseList(slow);
        
        // 3. 比较前半部分和后半部分
        ListNode p1 = head;
        ListNode p2 = secondHalf;
        while (p2 != null) {  // 后半部分较短或相等
            if (p1.val != p2.val) {
                return false;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        
        return true;
    }
    
    // 反转链表
    private ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}
```

### 详细演示（奇数节点）
```
链表: 1 → 2 → 3 → 2 → 1

步骤1: 找中点
------------------
slow 和 fast 都从 head 开始

第1次移动:
slow: 1 → 2
fast: 1 → 2 → 3

第2次移动:
slow: 2 → 3
fast: 3 → 2 → 1

第3次移动:
slow: 3
fast: 1 → null (fast.next = null，停止)

slow 指向中点 3

步骤2: 反转后半部分（从3开始）
------------------
原链表: 1 → 2 → 3 → 2 → 1

反转 3 → 2 → 1:
null ← 3 ← 2 ← 1

现在:
前半: 1 → 2 → 3
后半: 1 → 2 ← 3 (secondHalf指向1)

步骤3: 比较
------------------
p1 从 head (1) 开始
p2 从 secondHalf (1) 开始

比较:
p1=1, p2=1 ✓
p1=2, p2=2 ✓
p1=3, p2=3 ✓
p2 走到头，返回 true
```

### 详细演示（偶数节点）
```
链表: 1 → 2 → 2 → 1

步骤1: 找中点
------------------
第1次移动:
slow: 1 → 2
fast: 1 → 2 → 2

第2次移动:
slow: 2 (第二个2)
fast: 2 → 1 → null

fast.next = null，停止
slow 指向后半部分的起点

步骤2: 反转后半部分（从第二个2开始）
------------------
原链表: 1 → 2 → 2 → 1

反转 2 → 1:
null ← 2 ← 1

现在:
前半: 1 → 2
后半: 1 → 2 (secondHalf指向1)

步骤3: 比较
------------------
p1=1, p2=1 ✓
p1=2, p2=2 ✓
p2 走到头，返回 true

本质

回文链表问题的核心技巧：

1. 快慢指针 --- 找到中点，O（1） 空间
2. 反转链表 --- 使后半部分可以从前往后遍历
3. 双指针比较 --- 同时遍历两部分