Leetcode 25. Reverse Nodes in k-Group

最新推荐文章于 2025-05-21 19:43:17 发布

原创最新推荐文章于 2025-05-21 19:43:17 发布 · 223 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Leetcode

Leetcode 同时被 2 个专栏收录

409 篇文章

订阅专栏

Algorithm

260 篇文章

订阅专栏

本文探讨了在链表中逆序每K个节点的两种实现方案，详细介绍了算法的逻辑与步骤，提供了清晰的代码示例，适用于解决LeetCode上的逆序节点问题。

文章作者：Tyan
博客：noahsnail.com | 优快云 | 简书

1. Description

Reverse Nodes in k-Group

2. Solution

Version 1

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        return reverse(head, k);
    }
    
    ListNode* reverse(ListNode* node, int k) {
        int count = 0;
        vector<ListNode*> nodes;
        ListNode* current = node;
        while(current) {
            count++;
            nodes.push_back(current);
            if(count == k) {
                break;
            }
            current = current->next;
        }
        if(count < k) {
            return node;
        }
        nodes[0]->next = reverse(nodes[nodes.size() - 1]->next, k);
        for(int i = nodes.size() - 1; i > 0; i--) {
            nodes[i]->next = nodes[i - 1];
        }
        return nodes[nodes.size() - 1];
    }
};

Version 2

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        return reverse(head, k);
    }
    
    ListNode* reverse(ListNode* node, int k) {
        int count = 0;
        ListNode* current = node;
        while(current && count < k) {
            count++;
            current = current->next;
        }
        if(count < k) {
            return node;
        }
        ListNode* latter = node->next;
        node->next = reverse(current, k);
        ListNode* pre = node;
        current = node->next;
        while(count > 1) {
            ListNode* next = latter->next;
            latter->next = pre;
            pre = latter;
            latter = next;
            count--;
        }
        return pre;
    }
};