【算法笔记】不用库函数手撕力扣之力扣25:K 个一组翻转链表

题目链接

题解

方法1：数组标注

主要思路

利用分治的思想，先取K个节点，对这K个节点用递归的形式在弹栈的过程中降next指针的指向进行反转。 值得注意的地方就是反转之后的相邻K个节点之间的连接关系，要让反转后的每组的最后一个节点的next指向下一组的第一个节点(反转前下一组的最后一个节点)。

源代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseKGroup(struct ListNode* head, int k)
{
    struct ListNode* totalHead = head;
    struct ListNode* segmentHead = head;
    struct ListNode* segmentTail = head;
    struct ListNode* preHead = NULL;
    bool ifFirst = true;
    while(1)
    {
        for(int i = 1; i < k; i++)
        {
            if(segmentTail->next == NULL)
            {
                return totalHead;
            }
            segmentTail = segmentTail->next;
        }

        struct ListNode* nextHead = segmentTail->next;

        if(ifFirst)
        {
            ifFirst = false;
            totalHead = segmentTail;
        }
            
        subReverseKGroup(segmentHead, k);

        segmentHead->next = nextHead;
        if(preHead != NULL)
        {
            preHead->next = segmentTail;
        }
        preHead = segmentHead;
            
        if(nextHead == NULL)
            return totalHead;
        
        segmentHead = nextHead;
        segmentTail = nextHead;
    }
}


void subReverseKGroup(struct ListNode* head, int k)
{ //注意这个函数递归反转K个节点，但是反转后的最后一个节点(反转前第一个节点)指向的null
    if(k == 1)
        return;
    else
    {
        subReverseKGroup(head->next, k - 1);
        head->next->next = head;
        head->next = NULL;
    }
}

时空复杂度

• 用时：执行用时：8 ms, 在所有 C 提交中击败了70%的用户
• 内存：6.9 MB, 在所有 C 提交中击败了42%的用户

中途错误记录

• K个节点反转后的最后一个节点的next指向了下一组反转节点的最后一个节点(反转前本组的第一个节点)