LeetCode 第25题：K 个一组翻转链表

LeetCode 第25题：K 个一组翻转链表

题目描述

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

难度

困难

题目链接

https://leetcode.cn/problems/reverse-nodes-in-k-group/

示例

示例 1：

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

示例 2：

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

提示

• 链表中的节点数目为 n
• 1 <= k <= n <= 5000
• 0 <= Node.val <= 1000

解题思路

方法一：迭代法

使用迭代的方式，每次处理k个节点。

关键点：

1. 使用虚拟头节点简化操作
2. 每次翻转前先判断剩余节点数量是否足够
3. 保存每组k个节点的前驱和后继
4. 翻转k个节点后重新连接

具体步骤：

1. 创建虚拟头节点
2. 计算链表长度
3. 对于每组k个节点：
   • 判断剩余节点是否足够k个
   • 保存组的前驱和后继
   • 翻转k个节点
   • 连接翻转后的组
4. 返回虚拟头节点的下一个节点

时间复杂度：O(n)，其中n是链表的长度
空间复杂度：O(1)

方法二：递归法

利用递归的特性，将问题分解为子问题。

递归思路：

1. 基线条件：剩余节点不足k个
2. 对于每组k个节点：
   • 翻转当前k个节点
   • 递归处理后续节点
3. 返回新的头节点

代码实现

C# 实现（迭代法）

/*** Definition for singly-linked list.* public class ListNode {*     public int val;*     public ListNode next;*     public ListNode(int val=0, ListNode next=null) {*         this.val = val;*         this.next = next;*     }* }*/
public class Solution {public ListNode ReverseKGroup(ListNode head, int k) {if (head == null || k == 1) return head;// 创建虚拟头节点ListNode dummy = new ListNode(0);dummy.next = head;ListNode prev = dummy;ListNode curr = head;// 计算链表长度int length = 0;while (head != null) {length++;head = head.next;}// 处理每组k个节点for (int i = 0; i < length / k; i++) {// 翻转k个节点for (int j = 1; j < k; j++) {ListNode next = curr.next;curr.next = next.next;next.next = prev.next;prev.next = next;}prev = curr;curr = curr.next;}return dummy.next;}
}

C# 实现（递归法）

public class Solution {public ListNode ReverseKGroup(ListNode head, int k) {if (head == null || k == 1) return head;// 检查剩余节点是否足够k个ListNode curr = head;int count = 0;while (curr != null && count < k) {curr = curr.next;count++;}// 如果不足k个节点，返回原链表if (count < k) return head;// 翻转k个节点curr = head;ListNode prev = null;ListNode next = null;for (int i = 0; i < k; i++) {next = curr.next;curr.next = prev;prev = curr;curr = next;}// 递归处理后续节点head.next = ReverseKGroup(curr, k);return prev;}
}

代码详解

迭代版本：

1. 初始化：
   • 使用dummy节点简化操作
   • 计算链表总长度
2. 翻转过程：
   • 每次处理k个节点
   • 保持组内节点的连接关系
   • 更新前驱和后继指针
3. 边界处理：
   • 判断剩余节点数量
   • 处理不足k个节点的情况

递归版本：

1. 基线条件：
   • 检查剩余节点数量
   • 处理不足k个的情况
2. 递归过程：
   • 翻转当前k个节点
   • 递归处理后续节点
   • 连接翻转后的部分

执行结果

迭代版本：

• 执行用时：92 ms
• 内存消耗：38.2 MB

递归版本：

• 执行用时：88 ms
• 内存消耗：38.4 MB

总结与反思

1. 这是一道高难度的链表操作题目：
   • 考察链表的基本操作
   • 考察分组处理的思想
   • 考察边界情况的处理
2. 两种解法比较：
   • 迭代：空间效率好，实现较复杂
   • 递归：代码简洁，但空间开销大
3. 优化思路：
   • 预先计算长度避免重复遍历
   • 使用虚拟头节点简化操作
   • 仔细处理边界情况

相关题目

• LeetCode 第24题：两两交换链表中的节点
• LeetCode 第206题：反转链表
• LeetCode 第92题：反转链表 II
• LeetCode 第61题：旋转链表