leetcode — 25. K 个一组翻转链表 遇到问题求助下各位

题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶
你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

初步解法

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        vector<ListNode*> vecNode(k);

        int index = 0;
        while (head != nullptr && index < k)
        {
            vecNode[index++] = head;
            head = head->next;
        }

        if (index == k)
        {
            for (int i = vecNode.size() - 1; i > 0; i--)
            {
                vecNode[i]->next = vecNode[i - 1];
            }

            vecNode[0]->next = reverseKGroup(head, k);
            return vecNode.back();
        }

        return vecNode.front();
    }
};

使用 vector 保存前至多k个节点。然后通过递归实现该算法。但是这样空间复杂度为O(n)。

改进后的解法

class Solution {
public:
    int index;
    ListNode* ReverseKList(ListNode* head, int k, ListNode* &newHead)
    {
        if (index == k || head == nullptr)
        {
            return head;
        }
        else
        {
            index++;
            ListNode* retNode = ReverseKList(head->next, k, newHead);
            if (head->next != retNode)
            {
                head->next->next = head;
            }
            else
            {
                newHead = head;
            }

            return retNode;
        }
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* retNode = nullptr;
        ListNode* nextNode = nullptr;
        index = 0;
        nextNode = ReverseKList(head, k, retNode);

        if (index == k)
        {
            head->next = reverseKGroup(nextNode, k);
        }

        return retNode;
    }
};

这种解法不需要使用多余的空间保存各节点指针，因此空间复杂度是可以满足进阶要求的。

问题

在我的编译器上运行测试用例（ [1,2,3,4,5], 3）是没有报错的。但是在leetcode的网站上运行却出现了问题。暂时没有发现问题的根源，如果大家有能发现的还请帮忙指出来。