Leetcode 25. K 个一组翻转链表

JehanRio

已于 2023-09-04 12:19:09 修改

阅读量203

点赞数

分类专栏： Leetcode专栏文章标签：链表 leetcode 数据结构

于 2023-05-31 16:56:43 首次发布

本文链接：https://blog.csdn.net/weixin_51322383/article/details/130972788

版权

Leetcode专栏专栏收录该内容

278 篇文章 3 订阅

订阅专栏

文章详细介绍了如何解决LeetCode第25题，即如何将链表按K个节点一组进行翻转，提供了三种不同的C++和Go语言的代码实现，包括首刷自解、二刷调试和三刷自解的版本，每种实现都包含了一个辅助的反转子链表函数。

摘要由CSDN通过智能技术生成

题目

在这里插入图片描述
Leetcode 25. K 个一组翻转链表

代码（首刷自解）

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head || !head->next)
            return head;
        auto a = head;
        auto b = head;
        for(int i = 0; i < k; i++) {
            if(!b)
                return head;
            b = b->next;
        }
        auto new_head = reverse(a, b);
        a->next = reverseKGroup(b, k);
        return new_head;
    }
    ListNode* reverse(ListNode* a, ListNode* b) {
        if(a == b || a->next == b)
            return a;
        auto new_head = reverse(a->next, b);
        a->next->next = a;
        a->next = b;
        return new_head;
    }  
};

代码（8.6 二刷调试看解析）

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
        // write code here
        auto tail = head;
        for(int i = 0; i < k; i++) {
            if(!tail) {
                return head;
            }
            tail = tail->next;
        }
        auto newHead = reverse(head, tail);
        head->next = reverseKGroup(tail, k);
        return newHead;
    }
    ListNode* reverse(ListNode* head, ListNode* tail) {
        if(head == tail || head->next == tail)
            return head;
        auto newHead = reverse(head->next, tail);
        head->next->next = head;
        head->next =tail;
        return newHead;
    }
};

func reverseKGroup(head *ListNode, k int) *ListNode {
    tail := head
    for i := 0; i < k; i++ {
        if tail == nil {
            return head
        }
        tail = tail.Next
    }
    newHead := reverse(head, tail)
    head.Next = reverseKGroup(head.Next, k)
    return newHead

}
func reverse(head, tail *ListNode) *ListNode {
    if head == tail || head.Next == tail {
        return head
    }
    newHead := reverse(head.Next, tail)
    head.Next.Next = head
    head.Next = tail
    return newHead
}

代码（9.4 三刷自解）

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head)   
            return head;
        auto cur = head;
        for(int i = 0; i < k-1; i++) {
            if(!cur || !cur->next)
                return head;
            cur = cur->next;
        }
        auto next = cur->next;
        reverse(head, next);
        head->next = reverseKGroup(next, k);
        return cur;
    }
    ListNode* reverse(ListNode* head, ListNode* tail) {
        if(head == tail || head->next == tail)
            return head;
        auto newHead = reverse(head->next, tail);
        head->next->next = head;
        head->next = tail;
        return newHead;
    }
};