hot 100 第二十三题 23.反转链表

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

示例 1：

复制代码

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

示例 2：

复制代码

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

示例 3：

复制代码

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

这是反转链表 问题，是链表作的经典基础题。有迭代和递归两种解法。

核心思路

迭代法：逐个改变节点的 next 指针方向，从指向后继改为指向前驱。

复制代码

原链表: 1 → 2 → 3 → 4 → 5 → null

反转后: null ← 1 ← 2 ← 3 ← 4 ← 5
                                ↑
                              新头节点

解法1：迭代（推荐)

java 复制代码

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;  // 前一个节点
        ListNode curr = head;  // 当前节点
        
        while (curr != null) {
            ListNode next = curr.next;  // 保存下一个节点
            curr.next = prev;           // 反转指针
            prev = curr;                // prev 前移
            curr = next;                // curr 前移
        }
        
        return prev;  // prev 是新的头节点
    }
}
```

### 详细演示
```
原链表: 1 → 2 → 3 → null

初始状态:
prev = null
curr = 1
next = ?

第1轮:
------------------
next = curr.next = 2     // 保存下一个节点
curr.next = prev         // 1 → null
prev = curr              // prev 移到 1
curr = next              // curr 移到 2

状态: null ← 1    2 → 3 → null
             ↑    ↑
           prev  curr

第2轮:
------------------
next = curr.next = 3
curr.next = prev         // 2 → 1
prev = curr              // prev 移到 2
curr = next              // curr 移到 3

状态: null ← 1 ← 2    3 → null
                  ↑    ↑
                prev  curr

第3轮:
------------------
next = curr.next = null
curr.next = prev         // 3 → 2
prev = curr              // prev 移到 3
curr = next              // curr 移到 null

状态: null ← 1 ← 2 ← 3    null
                     ↑     ↑
                   prev   curr

第4轮:
------------------
curr == null，循环结束

返回 prev = 3（新的头节点）

最终链表: null ← 1 ← 2 ← 3
```

### 图解三指针
```
迭代过程的三个指针:

     prev  curr  next
       ↓    ↓     ↓
null   1 → 2  →  3 → null

步骤1: curr.next = prev
null ← 1    2 → 3 → null

步骤2: prev 和 curr 都向右移动
     prev  curr  next
       ↓    ↓     ↓
null ← 1    2  →  3 → null

重复...

解法2：递归

java 复制代码

class Solution {
    public ListNode reverseList(ListNode head) {
        // 递归终止条件
        if (head == null || head.next == null) {
            return head;
        }
        
        // 递归反转后面的链表
        ListNode newHead = reverseList(head.next);
        
        // 改变指针方向
        head.next.next = head;
        head.next = null;
        
        return newHead;
    }
}
```

### 详细演示
```
原链表: 1 → 2 → 3 → null

递归调用栈:
reverseList(1)
  ├─ reverseList(2)
  │   ├─ reverseList(3)
  │   │   └─ reverseList(null)  // 返回 3
  │   │   
  │   └─ 处理节点2和节点3的关系
  │
  └─ 处理节点1和节点2的关系

详细步骤:
------------------
调用 reverseList(1):
  调用 reverseList(2):
    调用 reverseList(3):
      调用 reverseList(null):
        返回 3
      
      // 现在处理节点3
      head = 3, head.next = null
      返回 3 (已经是尾节点，不需要操作)
    
    // 现在处理节点2
    head = 2, newHead = 3
    head.next.next = head  // 3.next = 2
    head.next = null       // 2.next = null
    
    状态: null ← 2 ← 3
    返回 newHead = 3
  
  // 现在处理节点1
  head = 1, newHead = 3
  head.next.next = head  // 2.next = 1
  head.next = null       // 1.next = null
  
  状态: null ← 1 ← 2 ← 3
  返回 newHead = 3

最终: null ← 1 ← 2 ← 3
                     ↑
                  newHead
```

### 递归图解
```
原链表: 1 → 2 → 3 → null

递归到最深层:
1 → 2 → 3 → null
        ↑
    递归终止，返回3

开始回溯:
------------------
处理 2 和 3:
head = 2, newHead = 3

head.next.next = head
即: 3.next = 2

1 → 2 ← 3
    ↓
   null

------------------
处理 1 和 2:
head = 1, newHead = 3

head.next.next = head
即: 2.next = 1

null ← 1 ← 2 ← 3
                ↑
             返回这个

复杂度分析

迭代法

时间复杂度： O（n） --- 遍历一遍链表
空间复杂度： O（1） --- 只用了三个指针

递归法

时间复杂度： O（n） --- 每个节点访问一次
空间复杂度： O（n） --- 递归调用栈深度

本质

反转链表的核心是指针作：

迭代法：自底向上，逐个改变指针方向
递归法：自顶向下，利用递归栈回溯时改变指针

两种方法思想不同，但都是改变指针的指向，从指向后继改为指向前驱。next