25. K 个一组翻转链表 - 力扣(LeetCode)

基础知识要求:

Java:方法、while循环、for循环、if else语句
Python: 方法、while循环、for循环、if else语句

题目:

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

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

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

示例 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

思路解析:

  1. 准备阶段
    • 首先,我们需要一个哑节点(dummy node)来简化头节点的处理。哑节点是一个不存储实际数据的节点,它的next指针指向链表的头节点。这样,我们就可以避免处理头节点翻转时的特殊情况。
    • 初始化三个指针:prev(前一个子链表的末尾节点)、curr(当前子链表的开始节点)和end(当前子链表的末尾节点)。开始时,prev指向哑节点,curr指向头节点。
  2. 循环处理阶段
    • 在每次循环中,我们首先使用getKthNode函数找到当前子链表的末尾节点end。如果endnull,说明剩下的节点数不足k个,我们不需要再翻转,直接结束循环。
    • 如果end不是null,说明当前子链表至少有k个节点,可以进行翻转。在翻转之前,我们需要保存下一个子链表的开始节点,即end.next,因为翻转后我们会丢失对它的引用。
    • 使用reverse函数翻转当前子链表。翻转后,curr(原来的开始节点)会变为翻转后的末尾节点,并且它的next指针会指向下一个子链表的开始节点。
    • 更新prevcurr的位置。prev指向curr(翻转后的末尾节点),curr指向下一个子链表的开始节点(即之前保存的end.next)。
  3. 结束阶段
    • 当循环结束后,我们得到了一个每k个节点一组翻转后的链表。这个链表的头节点是哑节点的next指针所指向的节点。
    • 返回哑节点的next指针作为结果。

Java代码示例:

java 复制代码
public class ListNode {  
    int val;  
    ListNode next;  
    ListNode(int x) { val = x; }  
}  
  
public class Solution {  
    public ListNode reverseKGroup(ListNode head, int k) {  
        if (head == null || k <= 1) {  
            return head;  
        }  
  
        // 创建一个哑节点(dummy node),简化头节点处理  
        ListNode dummy = new ListNode(0);  
        dummy.next = head;  
  
        ListNode prev = dummy; // 前一个子链表的末尾节点  
        ListNode curr = head; // 当前子链表的开始节点  
  
        while (curr != null) {  
            // 计算当前子链表的末尾节点  
            ListNode end = getKthNode(curr, k);  
            if (end == null) {  
                // 不足k个节点,无需翻转,直接退出循环  
                break;  
            }  
  
            // 翻转当前子链表  
            ListNode nextGroup = end.next; // 下一个子链表的开始节点  
            end.next = null; // 切断当前子链表与后续链表的连接  
            prev.next = reverse(curr); // 翻转后的子链表连接到前一个子链表的末尾  
            curr.next = nextGroup; // 翻转后的子链表的末尾节点指向下一个子链表的开始节点  
  
            // 更新指针  
            prev = curr; // 前一个子链表的末尾节点移动到当前翻转后的子链表的末尾  
            curr = nextGroup; // 当前子链表的开始节点移动到下一个子链表的开始节点  
        }  
  
        return dummy.next; // 返回修改后的链表头节点  
    }  
  
    // 翻转链表  
    private ListNode reverse(ListNode head) {  
        ListNode prev = null;  
        ListNode curr = head;  
        while (curr != null) {  
            ListNode next = curr.next;  
            curr.next = prev;  
            prev = curr;  
            curr = next;  
        }  
        return prev; // 返回翻转后的头节点  
    }  
  
    // 获取第k个节点  
    private ListNode getKthNode(ListNode head, int k) {  
        ListNode curr = head;  
        for (int i = 0; i < k && curr != null; i++) {  
            curr = curr.next;  
        }  
        return curr;  
    }  
}

Python代码示例:

python 复制代码
class ListNode:  
    def __init__(self, val=0, next=None):  
        self.val = val  
        self.next = next  
  
class Solution:  
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:  
        if not head or k <= 1:  
            return head  
  
        # 创建一个哑节点(dummy node),简化头节点处理  
        dummy = ListNode(0)  
        dummy.next = head  
  
        prev = dummy  # 前一个子链表的末尾节点  
        curr = head   # 当前子链表的开始节点  
  
        while curr:  
            # 计算当前子链表的末尾节点  
            end = self.getKthNode(curr, k)  
            if not end:  
                # 不足k个节点,无需翻转,直接退出循环  
                break  
  
            # 翻转当前子链表  
            next_group = end.next  # 下一个子链表的开始节点  
            end.next = None  # 切断当前子链表与后续链表的连接  
            prev.next = self.reverse(curr)  # 翻转后的子链表连接到前一个子链表的末尾  
            curr.next = next_group  # 翻转后的子链表的末尾节点指向下一个子链表的开始节点  
  
            # 更新指针  
            prev = curr  # 前一个子链表的末尾节点移动到当前翻转后的子链表的末尾  
            curr = next_group  # 当前子链表的开始节点移动到下一个子链表的开始节点  
  
        return dummy.next  # 返回修改后的链表头节点  
  
    # 翻转链表  
    def reverse(self, head: ListNode) -> ListNode:  
        prev = None  
        curr = head  
        while curr:  
            next_node = curr.next  
            curr.next = prev  
            prev = curr  
            curr = next_node  
        return prev  # 返回翻转后的头节点  
  
    # 获取第k个节点  
    def getKthNode(self, head: ListNode, k: int) -> ListNode:  
        curr = head  
        for _ in range(k):  
            if curr:  
                curr = curr.next  
            else:  
                return None  
        return curr
相关推荐
灵智工坊LingzhiAI1 小时前
人体坐姿检测系统项目教程(YOLO11+PyTorch+可视化)
人工智能·pytorch·python
karmueo461 小时前
视频序列和射频信号多模态融合算法Fusion-Vital解读
算法·音视频·多模态
小汉堡编程2 小时前
数据结构——vector数组c++(超详细)
数据结构·c++
程序员张33 小时前
Maven编译和打包插件
java·spring boot·maven
写代码的小球4 小时前
求模运算符c
算法
ybq195133454314 小时前
Redis-主从复制-分布式系统
java·数据库·redis
weixin_472339465 小时前
高效处理大体积Excel文件的Java技术方案解析
java·开发语言·excel
小毛驴8505 小时前
Linux 后台启动java jar 程序 nohup java -jar
java·linux·jar
雾里看山6 小时前
顺序表VS单链表VS带头双向循环链表
数据结构·链表
DKPT6 小时前
Java桥接模式实现方式与测试方法
java·笔记·学习·设计模式·桥接模式