单链表反转：迭代与递归全解析（整个 / 前 N 个 / 区间 / K 个一组）

概述链表节点定义核心思想：迭代 vs 递归迭代：三指针递归：后序遍历四大经典问题 1. 反转整个链表（LeetCode 206）2. 反转前 N 个节点 3. 反转链表的一部分（区间 [left, right]，LeetCode 92）4. K 个一组反转链表（LeetCode 25）代码实现复杂度与解法对比关键要点扩展思考相关文章

3131 字

16 分钟

单链表反转：迭代与递归全解析（整个 / 前 N 个 / 区间 / K 个一组）

2026-09-01

算法

链表

/

反转

/

迭代

/

递归

/

双指针

/

C

/

C++

/

JavaScript

概述#

反转单链表是链表类算法题的「地基」，几乎所有链表的进阶操作（回文判断、K 个一组反转、部分反转）都以它为基础。

反转的本质只有一句话：把每条 next 指针的方向反过来。

1
反转前：1 → 2 → 3 → 4 → null
2
反转后：4 → 3 → 2 → 1 → null

围绕「反转」这一核心，本文按难度递进讲四个经典问题：

#	问题	对应题目	难度
1	反转整个链表	LeetCode 206	简单
2	反转前 N 个节点	206 的变体	中等
3	反转链表的一部分（区间）	LeetCode 92	中等
4	K 个一组反转链表	LeetCode 25	困难

每个问题都给出迭代与递归两种解法。掌握后你会发现：后三个问题其实都是第一个问题的「套壳」。

前置知识

链表节点：只能沿 next 单向前进

指针重连：反转的本质是修改引用

递归：理解「后序遍历」式的处理顺序

链表节点定义#

本文所有代码共用下面的单链表节点结构：

1
typedef struct ListNode {
2
    int val;
3
    struct ListNode *next;
4
} ListNode;

1
struct ListNode {
2
    int val;
3
    ListNode *next;
4
    ListNode() : val(0), next(nullptr) {}
5
    ListNode(int x) : val(x), next(nullptr) {}
6
    ListNode(int x, ListNode *next) : val(x), next(next) {}
7
};

1
class ListNode {
2
    constructor(val, next) {
3
        this.val = (val === undefined ? 0 : val);
4
        this.next = (next === undefined ? null : next);
5
    }
6
}

核心思想：迭代 vs 递归#

迭代：三指针#

迭代解法用三个指针 prev、curr、next，每一轮重复四步：

1
初始：prev = null, curr = head
2

3
null   1 → 2 → 3 → 4 → null
4
 ^     ^
5
prev  curr
6

7
每一轮：
8
  1. next = curr.next   // 先保存后继，防止断链
9
  2. curr.next = prev   // 当前节点反向指向
10
  3. prev = curr        // prev 前移
11
  4. curr = next        // curr 前移

循环结束的条件是 curr 走到 null，此时 prev 正好指向反转后的新头节点。

关键点：第 1 步「先保存 next」绝不能省，否则 curr.next 被改后，原本的后续链表就再也找不回来了。

递归：后序遍历#

递归解法的精髓是「先反转后面的，再处理当前的」，本质上是链表的后序遍历：

1
reverseList(1→2→3→4)
2
  = 先递归反转后面的：reverseList(2→3→4)  →  4→3→2
3
    再让「2」指向「1」：head.next.next = head
4
    最后断开「1」的旧指向：head.next = null

核心只有两行：

1
head.next.next = head   // 让后继节点反向指向自己
2
head.next = null        // 断开原来的正向指向

递归的基准情况是 head 为空或 head.next 为空（只剩一个节点，无需反转），此时直接返回 head。

四大经典问题#

1. 反转整个链表（LeetCode 206）#

思路（迭代）：三指针从头走到尾，见上文。

思路（递归）：先反转 head.next 开始的子链，再让 head.next 指向 head，最后断开 head.next。

1
输入：1 → 2 → 3 → 4 → 5 → null
2
输出：5 → 4 → 3 → 2 → 1 → null

2. 反转前 N 个节点#

思路（迭代）：只反转前 n 个，反转结束后把原头节点（此时已是反转段的尾）接到剩余链上。

1
反转前：1 → 2 → 3 → 4 → 5 → null，n = 3
2
反转后：3 → 2 → 1 → 4 → 5 → null
3
                          └─ 剩余部分原样保留

思路（递归）：与「反转整个」几乎一样，唯一区别是反转结束后，尾节点要接到第 n+1 个节点上。为此引入一个后继指针 successor，在递归到 n == 1 时记录下「第 n 个节点的后继」，并在回溯时把尾节点的 next 指向它。

successor 正是「反转前 N 个」能过渡到「区间反转」的关键桥梁。

3. 反转链表的一部分（区间 [left, right]，LeetCode 92）#

思路（迭代）：用虚拟头节点 dummy 定位到 left 的前驱 pre，然后对 [left, right] 这段做「头插法」反转——每次把 curr.next 摘下来插到 pre 后面，共执行 right - left 次。

1
输入：1 → 2 → 3 → 4 → 5，left = 2, right = 4
2
输出：1 → 4 → 3 → 2 → 5
3
           └─ [2,3,4] 被反转 ─┘

思路（递归）：递归地缩小问题规模。当 left == 1 时，区间反转就退化为「反转前 right 个」；否则不断移动头指针，把 left 和 right 同时减 1 向深处递归，回来时把当前头接回去。

4. K 个一组反转链表（LeetCode 25）#

思路（迭代）：用 pre 和 end 两个指针扫描，每次先把 end 前进 k 步「探路」：

若剩余不足 k 个，直接结束；
否则记录本组起点 start 和下一组起点 next，把本组截断后整体反转，再接回原链。

思路（递归）：先判断剩余是否够 k 个，不够则原样返回；够则反转前 k 个（复用「反转前 N 个」），再递归处理剩余部分并接回。

1
输入：1 → 2 → 3 → 4 → 5，k = 2
2
输出：2 → 1 → 4 → 3 → 5
3
      └ 反转 ┘ └ 反转 ┘ └ 不足 k 个，原样 ┘

代码实现#

每种语言都包含四个问题 × 两种解法共 8 个函数，按注释分区。递归「反转前 N 个」用到的 successor 是模块级（文件级）变量。

1
#include <stddef.h>
2

3
typedef struct ListNode {
4
    int val;
5
    struct ListNode *next;
6
} ListNode;
7

8
/* ============ 1. 反转整个链表 ============ */
9

10
/* 迭代 */
11
ListNode* reverseList(ListNode* head) {
12
    ListNode* prev = NULL;
13
    ListNode* curr = head;
14
    while (curr) {
15
        ListNode* next = curr->next; /* 先保存后继 */
16
        curr->next = prev;           /* 反转当前指向 */
17
        prev = curr;                 /* prev 前移 */
18
        curr = next;                 /* curr 前移 */
19
    }
20
    return prev;
21
}
22

23
/* 递归 */
24
ListNode* reverseListRecursive(ListNode* head) {
25
    if (head == NULL || head->next == NULL) return head;
26
    ListNode* last = reverseListRecursive(head->next);
27
    head->next->next = head; /* 后继指向自己 */
28
    head->next = NULL;       /* 断开原指向 */
29
    return last;
30
}
31

32
/* ============ 2. 反转前 N 个节点 ============ */
33

34
/* 迭代 */
35
ListNode* reverseN(ListNode* head, int n) {
36
    ListNode* prev = NULL;
37
    ListNode* curr = head;
38
    for (int i = 0; i < n && curr; i++) {
39
        ListNode* next = curr->next;
40
        curr->next = prev;
41
        prev = curr;
42
        curr = next;
43
    }
44
    head->next = curr; /* 原头节点接上剩余部分 */
45
    return prev;
46
}
47

48
/* 递归（借助后继指针 successor） */
49
static ListNode* successor = NULL;
50

51
ListNode* reverseNRecursive(ListNode* head, int n) {
52
    if (n == 1) {
53
        successor = head->next; /* 记录第 n+1 个节点 */
54
        return head;
55
    }
56
    ListNode* last = reverseNRecursive(head->next, n - 1);
57
    head->next->next = head;
58
    head->next = successor; /* 反转后的尾节点接上后继 */
59
    return last;
60
}
61

62
/* ============ 3. 反转链表的一部分（区间 [left, right]） ============ */
63

64
/* 迭代（头插法） */
65
ListNode* reverseBetween(ListNode* head, int left, int right) {
66
    ListNode dummy;
67
    dummy.next = head;
68
    ListNode* pre = &dummy;
69
    for (int i = 1; i < left; i++) pre = pre->next; /* 定位到 left 前驱 */
70

71
    ListNode* curr = pre->next;
72
    for (int i = 0; i < right - left; i++) {
73
        ListNode* next = curr->next;
74
        curr->next = next->next;
75
        next->next = pre->next;
76
        pre->next = next;
77
    }
78
    return dummy.next;
79
}
80

81
/* 递归（退化为反转前 right 个） */
82
ListNode* reverseBetweenRecursive(ListNode* head, int left, int right) {
83
    if (left == 1) {
84
        return reverseNRecursive(head, right);
85
    }
86
    head->next = reverseBetweenRecursive(head->next, left - 1, right - 1);
87
    return head;
88
}
89

90
/* ============ 4. K 个一组反转 ============ */
91

92
/* 迭代 */
93
ListNode* reverseKGroup(ListNode* head, int k) {
94
    ListNode dummy;
95
    dummy.next = head;
96
    ListNode* pre = &dummy;
97
    ListNode* end = &dummy;
98

99
    while (end->next) {
100
        for (int i = 0; i < k && end; i++) end = end->next; /* 探路 */
101
        if (!end) break; /* 不够 k 个，结束 */
102

103
        ListNode* start = pre->next;
104
        ListNode* next = end->next;      /* 记录下一组起点 */
105
        end->next = NULL;                /* 截断本组 */
106
        pre->next = reverseList(start);  /* 反转本组 */
107
        start->next = next;              /* 接回后续 */
108
        pre = start;                     /* pre 指向本组末尾 */
109
        end = pre;                       /* 重置 end */
110
    }
111
    return dummy.next;
112
}
113

114
/* 递归 */
115
ListNode* reverseKGroupRecursive(ListNode* head, int k) {
116
    ListNode* end = head;
117
    for (int i = 0; i < k; i++) {
118
        if (!end) return head; /* 不够 k 个，保持原样 */
119
        end = end->next;
120
    }
121

122
    ListNode* newHead = reverseN(head, k);               /* 反转前 k 个 */
123
    head->next = reverseKGroupRecursive(end, k);         /* 递归处理剩余 */
124
    return newHead;
125
}

1
struct ListNode {
2
    int val;
3
    ListNode *next;
4
    ListNode() : val(0), next(nullptr) {}
5
    ListNode(int x) : val(x), next(nullptr) {}
6
    ListNode(int x, ListNode *next) : val(x), next(next) {}
7
};
8

9
class Solution {
10
public:
11
    /* ============ 1. 反转整个链表 ============ */
12

13
    ListNode* reverseList(ListNode* head) {
14
        ListNode* prev = nullptr;
15
        ListNode* curr = head;
16
        while (curr) {
17
            ListNode* next = curr->next;
18
            curr->next = prev;
19
            prev = curr;
20
            curr = next;
21
        }
22
        return prev;
23
    }
24

25
    ListNode* reverseListRecursive(ListNode* head) {
26
        if (!head || !head->next) return head;
27
        ListNode* last = reverseListRecursive(head->next);
28
        head->next->next = head;
29
        head->next = nullptr;
30
        return last;
31
    }
32

33
    /* ============ 2. 反转前 N 个节点 ============ */
34

35
    ListNode* reverseN(ListNode* head, int n) {
36
        ListNode* prev = nullptr;
37
        ListNode* curr = head;
38
        for (int i = 0; i < n && curr; i++) {
39
            ListNode* next = curr->next;
40
            curr->next = prev;
41
            prev = curr;
42
            curr = next;
43
        }
44
        head->next = curr;
45
        return prev;
46
    }
47

48
    ListNode* reverseNRecursive(ListNode* head, int n) {
49
        if (n == 1) {
50
            successor = head->next;
51
            return head;
52
        }
53
        ListNode* last = reverseNRecursive(head->next, n - 1);
54
        head->next->next = head;
55
        head->next = successor;
56
        return last;
57
    }
58

59
    /* ============ 3. 反转链表的一部分 ============ */
60

61
    ListNode* reverseBetween(ListNode* head, int left, int right) {
62
        ListNode dummy(0, head);
63
        ListNode* pre = &dummy;
64
        for (int i = 1; i < left; i++) pre = pre->next;
65

66
        ListNode* curr = pre->next;
67
        for (int i = 0; i < right - left; i++) {
68
            ListNode* next = curr->next;
69
            curr->next = next->next;
70
            next->next = pre->next;
71
            pre->next = next;
72
        }
73
        return dummy.next;
74
    }
75

76
    ListNode* reverseBetweenRecursive(ListNode* head, int left, int right) {
77
        if (left == 1) {
78
            return reverseNRecursive(head, right);
79
        }
80
        head->next = reverseBetweenRecursive(head->next, left - 1, right - 1);
81
        return head;
82
    }
83

84
    /* ============ 4. K 个一组反转 ============ */
85

86
    ListNode* reverseKGroup(ListNode* head, int k) {
87
        ListNode dummy(0, head);
88
        ListNode* pre = &dummy;
89
        ListNode* end = &dummy;
90

91
        while (end->next) {
92
            for (int i = 0; i < k && end; i++) end = end->next;
93
            if (!end) break;
94

95
            ListNode* start = pre->next;
96
            ListNode* next = end->next;
97
            end->next = nullptr;
98
            pre->next = reverseList(start);
99
            start->next = next;
100
            pre = start;
101
            end = pre;
102
        }
103
        return dummy.next;
104
    }
105

106
    ListNode* reverseKGroupRecursive(ListNode* head, int k) {
107
        ListNode* end = head;
108
        for (int i = 0; i < k; i++) {
109
            if (!end) return head;
110
            end = end->next;
111
        }
112
        ListNode* newHead = reverseN(head, k);
113
        head->next = reverseKGroupRecursive(end, k);
114
        return newHead;
115
    }
116

117
private:
118
    ListNode* successor = nullptr; /* 递归「反转前 N 个」用到的后继指针 */
119
};

1
class ListNode {
2
    constructor(val, next) {
3
        this.val = (val === undefined ? 0 : val);
4
        this.next = (next === undefined ? null : next);
5
    }
6
}
7

8
// 递归「反转前 N 个」用到的后继指针
9
let successor = null;
10

11
/* ============ 1. 反转整个链表 ============ */
12

13
function reverseList(head) {
14
    let prev = null;
15
    let curr = head;
16
    while (curr) {
17
        const next = curr.next;
18
        curr.next = prev;
19
        prev = curr;
20
        curr = next;
21
    }
22
    return prev;
23
}
24

25
function reverseListRecursive(head) {
26
    if (!head || !head.next) return head;
27
    const last = reverseListRecursive(head.next);
28
    head.next.next = head;
29
    head.next = null;
30
    return last;
31
}
32

33
/* ============ 2. 反转前 N 个节点 ============ */
34

35
function reverseN(head, n) {
36
    let prev = null;
37
    let curr = head;
38
    for (let i = 0; i < n && curr; i++) {
39
        const next = curr.next;
40
        curr.next = prev;
41
        prev = curr;
42
        curr = next;
43
    }
44
    head.next = curr;
45
    return prev;
46
}
47

48
function reverseNRecursive(head, n) {
49
    if (n === 1) {
50
        successor = head.next;
51
        return head;
52
    }
53
    const last = reverseNRecursive(head.next, n - 1);
54
    head.next.next = head;
55
    head.next = successor;
56
    return last;
57
}
58

59
/* ============ 3. 反转链表的一部分 ============ */
60

61
function reverseBetween(head, left, right) {
62
    const dummy = new ListNode(0, head);
63
    let pre = dummy;
64
    for (let i = 1; i < left; i++) pre = pre.next;
65

66
    const curr = pre.next;
67
    for (let i = 0; i < right - left; i++) {
68
        const next = curr.next;
69
        curr.next = next.next;
70
        next.next = pre.next;
71
        pre.next = next;
72
    }
73
    return dummy.next;
74
}
75

76
function reverseBetweenRecursive(head, left, right) {
77
    if (left === 1) {
78
        return reverseNRecursive(head, right);
79
    }
80
    head.next = reverseBetweenRecursive(head.next, left - 1, right - 1);
81
    return head;
82
}
83

84
/* ============ 4. K 个一组反转 ============ */
85

86
function reverseKGroup(head, k) {
87
    const dummy = new ListNode(0, head);
88
    let pre = dummy;
89
    let end = dummy;
90

91
    while (end.next) {
92
        for (let i = 0; i < k && end; i++) end = end.next;
93
        if (!end) break;
94

95
        const start = pre.next;
96
        const next = end.next;
97
        end.next = null;
98
        pre.next = reverseList(start);
99
        start.next = next;
100
        pre = start;
101
        end = pre;
102
    }
103
    return dummy.next;
104
}
105

106
function reverseKGroupRecursive(head, k) {
107
    let end = head;
108
    for (let i = 0; i < k; i++) {
109
        if (!end) return head;
110
        end = end.next;
111
    }
112
    const newHead = reverseN(head, k);
113
    head.next = reverseKGroupRecursive(end, k);
114
    return newHead;
115
}

复杂度与解法对比#

问题	迭代时间	迭代空间	递归时间	递归空间
反转整个链表	O(n)	O(1)	O(n)	O(n)（递归栈）
反转前 N 个	O(n)	O(1)	O(n)	O(n)
区间反转	O(n)	O(1)	O(n)	O(n)
K 个一组	O(n)	O(1)	O(n)	O(n/k)

迭代 vs 递归：

迭代：空间 O(1)，无栈溢出风险，工程首选。
递归：代码更简洁、语义更直观，但每次调用都占用栈空间，n 很大时可能栈溢出；其价值更多在于「思路迁移」——reverseN + successor 的写法能干净地推出区间反转和 K 组反转。

关键要点#

反转前先保存 next：这是迭代解法的命门，忘记保存就会断链。
head.next.next = head 是递归的灵魂：一句「让后继指向自己」完成了反向重连。
successor 是「前 N 个」到「区间」的桥梁：记录「第 n+1 个节点」，让反转段能正确接回剩余部分。
区间反转 = 定位前驱 + 头插法：dummy 节点统一了 left = 1 的边界情况。
K 组反转先「探路」：判断剩余是否够 k 个，不够则原样保留，这是它与「整个反转」的唯一区别。

扩展思考#

回文链表（LeetCode 234）：先快慢指针找中点，再反转后半段，最后双指针比较——正是「反转」+「双指针」的组合拳。
递归栈风险：链表长度到 10^5 时，递归深度可能超出默认栈上限，此时应改用迭代。
反转整个链表还有一种「尾插法」写法（每轮把 curr 插到 dummy 之后），与区间反转的头插法一脉相承，可以自行尝试。

概述#