面试必过：LeetCode206反转链表的4种解法（含Java代码与底层逻辑）

在Java后端与算法面试中，算法题：反转链表（LeetCode 206）是考察链表操作能力的“黄金题型”——它不仅是所有链表变形题的基础，更能直接反映你对指针操作、递归思维的底层理解。根据鳄鱼java的面试案例库统计，90%的中大厂Java面试都会考察这道题，其中仅能写出代码但无法讲清逻辑的候选人通过率不足25%，而能结合底层思维讲解优化思路的候选人通过率高达90%以上。这道题的核心价值，是通过一个简单的反转操作，筛选出具备“底层逻辑+代码优化”双能力的Java开发者，而非只会背题的应试者。

一、面试题本质：从“反转”到“指针思维考察”

很多候选人以为算法题：反转链表（LeetCode 206）只是要你写出反转代码，但实际上，面试官的真实意图是考察两个核心能力：一是你能否理解单链表的底层存储逻辑（Java中对象引用的传递规则）；二是你能否在“时间复杂度”与“空间复杂度”之间找到最优解。

鳄鱼java的资深面试官分享：这道题的评分标准分三个层级：及格级（能写出至少一种解法）、良好级（能讲清时间空间复杂度）、优秀级（能对比多种解法，结合场景选择最优）。优秀级候选人往往能直接进入二面，因为他们具备Java项目中处理链表结构的核心思维——比如消息队列、日志链表、链表缓存等场景，都需要反转操作的底层逻辑支持。

二、前置知识：Java单链表的底层逻辑

要解这道题，必须先理解Java中单链表的存储本质：单链表的每个节点是一个Java对象，包含一个数据域（val）和一个引用域（next），单链表的反转核心是改变节点的next指针指向，而非新建节点。Java实现的单链表节点代码如下：

 
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; } 
} 

三、解法1：双指针迭代（面试首选，空间O(1)）

双指针迭代是算法题：反转链表（LeetCode 206）的面试最优解，因为它的时间复杂度为O(n)，空间复杂度为O(1)，完全符合面试对“高效”的要求，也是鳄鱼java的算法训练营中最先教授的解法。

核心思路：用两个指针分别指向当前节点（cur）和前一个节点（prev），遍历链表时，每次保存当前节点的下一个节点（next），然后将当前节点的next指向prev，最后移动prev和cur指针，直到cur为空，返回prev作为新的头节点。

Java代码与步骤注释：

 
public ListNode reverseList(ListNode head) { 
    // 处理空链表或单个节点的情况 
    if (head == null || head.next == null) { 
        return head; 
    } 
    ListNode prev = null; // 前一个节点，初始为null（原链表尾节点的next为null） 
    ListNode cur = head;  // 当前节点，初始为头节点 
    while (cur != null) { 
        ListNode next = cur.next; // 保存当前节点的下一个节点，防止链表断裂 
        cur.next = prev;          // 反转当前节点的指针指向，指向prev 
        prev = cur;               // prev指针移动到当前节点 
        cur = next;               // cur指针移动到下一个节点 
    } 
    return prev; // 循环结束后，prev指向原链表的尾节点，即新链表的头节点 
} 

时间空间复杂度：时间O(n)，遍历一次链表；空间O(1)，仅使用3个指针变量，无额外空间占用。

面试得分点：是否处理了空链表和单个节点的边界情况，是否能清晰讲解“保存next节点”的必要性（防止链表断裂），这是面试官高频追问的点。

四、解法2：递归（思维进阶，代码简洁）

递归解法是算法题：反转链表（LeetCode 206）的思维进阶解法，代码简洁但需要理解Java递归的栈帧机制，适合在面试中展示思维深度，鳄鱼java的算法训练营中会专门讲解递归的栈帧过程。

核心思路：将大问题拆解为子问题——反转当前节点和剩余链表的子问题。递归终止条件是当前节点为空或下一个节点为空，然后递归反转剩余链表，最后调整当前节点的指针指向。

Java代码与栈帧分析：

 
public ListNode reverseList(ListNode head) { 
    // 递归终止条件：空链表或单个节点，直接返回（栈帧的终止层） 
    if (head == null || head.next == null) { 
        return head; 
    } 
    // 递归调用，反转head.next之后的链表，返回新的头节点（原链表的尾节点） 
    ListNode newHead = reverseList(head.next); 
    // 调整当前节点的指针：让head.next的next指向head（反转指针） 
    head.next.next = head; 
    // 防止循环引用，将当前节点的next置为null 
    head.next = null; 
    // 返回新的头节点 
    return newHead; 
} 

栈帧分析：比如反转链表1->2->3，递归会先调用到reverseList(3)，返回3作为newHead；然后回到reverseList(2)，让2.next.next=2（即3.next=2），2.next=null；最后回到reverseList(1)，让1.next.next=1（即2.next=1），1.next=null，最终返回3作为新头节点。

时间空间复杂度：时间O(n)，递归调用n次；空间O(n)，递归栈帧的空间占用（最坏情况链表长度为n，栈深度为n），因此空间效率不如双指针迭代，但代码更简洁。

五、解法3：头插法（新手友好，直观易懂）

头插法是算法题：反转链表（LeetCode 206）的新手友好解法，思路直观，适合刚接触链表的开发者理解，但其本质与双指针迭代类似，只是通过虚拟头节点简化指针操作。

核心思路：新建一个虚拟头节点（dummy），遍历原链表，将每个节点插入到虚拟头节点的next位置，这样原链表的节点会被逆序连接到dummy之后，最后返回dummy.next作为新头节点。

Java代码：

 
public ListNode reverseList(ListNode head) { 
    ListNode dummy = new ListNode(-1); // 虚拟头节点 
    ListNode cur = head; 
    while (cur != null) { 
        ListNode next = cur.next; // 保存下一个节点 
        cur.next = dummy.next;    // 将当前节点的next指向dummy的next 
        dummy.next = cur;         // 将dummy的next指向当前节点（头插） 
        cur = next;               // 移动cur到下一个节点 
    } 
    return dummy.next; 
} 

时间空间复杂度：时间O(n)，遍历一次链表；空间O(1)，仅使用虚拟头节点和指针变量，空间效率与双指针迭代相同。

六、面试高频陷阱与Java场景优化

在算法题：反转链表（LeetCode 206）的面试中，以下3个陷阱是面试官最爱挖的坑，根据鳄鱼java的面试案例统计，错误率均超80%：

陷阱1：未处理空链表或单个节点的情况 很多Java开发者写出的代码在head为null时会抛出空指针异常，面试中必须先处理边界情况：if