Leetcode 206. 反转链表

最新推荐文章于 2025-09-28 21:01:06 发布

原创最新推荐文章于 2025-09-28 21:01:06 发布 · 167 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Leetcode #链表反转

编程算法专栏收录该内容

14 篇文章

订阅专栏

本文深入解析链表数据结构，提供递归与迭代两种反转链表的策略，详细阐述其思路、复杂度及代码实现，是理解与掌握链表操作的重要资源。

文章目录

1. 数据结构
2. 递归策略
3. 迭代策略

1. 数据结构

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}

2. 递归策略

2.1 思路

递归调用不影响当前节点，即当前节点 $n_{k}$ 的指针仍然指向原链表的下一节点 $n_{k+1}$ ，而 $n_{k+1}$ 已经完成反转，变成链表末尾。因此，head.next.next 可以快速定位到反转链表的尾部，即当前节点的移动位置。

ListNode node = reverseList(head.next); 对 $n_{k+1}, ……, n_{m}$ 部分链表进行反转，返回反转链表的头结点；
head.next.next = head; 将当前节点移动到链表末尾；
head.next = null; 将当前节点的指针置空。

2.2 复杂度

时间复杂度 O(n)
空间复杂度 O(n)：隐式使用递归栈，递归深度为 $n$ 。

2.3 代码

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode node = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return node;
    }
}

3. 迭代策略

3.1 思路

该思路与头插法类似，每次循环将当前节点插入链表头部，同时更新头节点。

ListNode node = head.next; 暂存下一节点；
head.next = pre; 更新当前节点的指针为原头节点；
pre = head; 更新头结点为当前节点；
head = node; 继续遍历下一节点。

3.2 复杂度

时间复杂度 O(n)
空间复杂度 O(1)

3.3 代码

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode pre = null;
        while (head != null) {
            ListNode node = head.next;
            head.next = pre;
            pre = head;
            head = node;
        }
        return pre;
    }
}