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题：旋转链表