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

合集 - 算法笔记(41)

1.LeetCode 第10题：正则表达式匹配02-092.LeetCode 第1题：两数之和02-073.LeetCode 第2题：两数相加02-074.LeetCode 第3题：无重复字符的最长子串02-075.LeetCode 第4题：寻找两个正序数组的中位数02-086.LeetCode 第8题：字符串转换整数 (atoi)02-097.LeetCode 第7题：整数反转02-098.LeetCode 第6题：Z字形变换02-099.LeetCode 第5题：最长回文子串02-0810.LeetCode 第9题：回文数02-0911.LeetCode 第11题：盛最多水的容器02-1012.LeetCode 第12题：整数转罗马数字02-1013.LeetCode 第13题：罗马数字转整数02-1014.LeetCode 第14题：最长公共前缀02-1115.LeetCode 第15题：三数之和02-1116.LeetCode 第16题：最接近的三数之和02-1117.LeetCode 第17题：电话号码的字母组合02-1118.LeetCode 第18题：四数之和02-1119.LeetCode 第19题：删除链表的倒数第N个结点02-1220.LeetCode 第20题：有效的括号02-1321.LeetCode 第21题：合并两个有序链表02-1322.LeetCode 第22题：括号生成02-1323.LeetCode 第23题：合并K个升序链表02-1324.LeetCode 第24题：两两交换链表中的节点02-15

25.LeetCode 第25题：K 个一组翻转链表02-15

26.LeetCode 第26题：删除有序数组中的重复项02-1527.LeetCode 第27题：移除元素02-1528.LeetCode 第28题：找出字符串中第一个匹配项的下标02-1629.LeetCode 第29题：两数相除02-1630.LeetCode 第30题：串联所有单词的子串02-1631.LeetCode 第31题：下一个排列02-1632.LeetCode 第32题：最长有效括号02-1733.LeetCode 第33题：搜索旋转排序数组02-1734.LeetCode 第34题：在排序数组中查找元素的第一个和最后一个位置02-1835.LeetCode 第35题：搜索插入位置02-1836.LeetCode 第36题：有效的数独02-1937.LeetCode 第37题：解数独02-1938.LeetCode 第38题：外观数列02-2039.LeetCode 第39题：组合总和02-2040.LeetCode 第40题：组合总和 II02-2441.LeetCode 第41题：缺失的第一个正数02-24

收起

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