【leetcode】25 K 个一组翻转链表（链表）

题目链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/
【hard】

题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

• 你的算法只能使用常数的额外空间。
• 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

思路

（1）用变量记录每一组开始的第一个节点和最后一个节点，直接逆序调整
（2）让该组反转的第一个节点（原最后节点）与之前组的最后一个节点连接上；将该组反转后最后一个节点（原第一节点）连接下一个节点

复杂度分析

• 时间复杂度：O（n）
• 空间复杂度：O（1）

代码

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head || !head->next || k<2) return head;

        ListNode *pNode = head;
        ListNode *dummy = new ListNode(-1);
        ListNode *pPrev = dummy;
        dummy->next = head; // 避免k>链表长度的情况
        while (pNode){
            int i = 2;
            ListNode *pBegin = pNode;       // 该组第一个节点
            ListNode *pEnd = pNode->next;   // 该组最后节点

            while(pEnd && i < k){
                pEnd = pEnd->next;
                ++ i;
            }
            if (!pEnd) break;               // 不足k个不反转
            ListNode *pNext = pEnd->next;
            reverseCore(pPrev,pNext, pBegin, pEnd);
            pPrev = pBegin;
            pNode = pNext;
        }
        return dummy->next;
    }

private:
    // 左边相连节点/右边相连节点/区间开始节点/区间结束节点
    void reverseCore(ListNode *left, ListNode *right, ListNode *begin, ListNode *end){
        ListNode *pNode = begin;
        ListNode *pPrev = nullptr;
        while (pNode!=right){
            ListNode *pNext = pNode->next;
            pNode->next = pPrev;
            pPrev = pNode;
            pNode = pNext;
        }

        left->next = pPrev;     // 与左边连接
        begin->next = right;    // 与右边连接
    }
};