25. K 个一组翻转链表

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

示例：

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

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

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

class Solution {
public:
    pair<ListNode*, ListNode*> subReverse(ListNode* head, ListNode* tail) {
        ListNode* prev = tail->next;   //尾部的节点将来会变成本子链表的前驱节点
        ListNode* cur = head;   
        while (prev!=tail) {	//翻转链表的标准写法，注意因为没有NULL所以，退出条件有变动。
            ListNode* next = cur->next;
            cur->next = prev;
            prev = cur;
            cur = next;
        }
        return {tail, head};  //头尾互换
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* hair = new ListNode(0);
        hair->next = head;
        ListNode* pre = hair;
        while (head) {
            ListNode* tail = pre;
            for (int i=0; i<k; ++i) { //判断剩下的节点数有没有k个，如果有tail就称为真正的tail，
                tail = tail->next;    //如果不足k个就说明整个链表已经翻转完毕，可以直接返回了。
                if (!tail) {		  //返回的条件
                    return hair->next;
                }
            }
            ListNode* next = tail->next; //记录下后续节点，用于后续的拼接
            //现在已经获得了需要翻转的子链的头结点和尾节点，可以调用函数了
            pair<ListNode*, ListNode*> result = subReverse(head, tail);
            head = result.first;  //头变尾，尾变头
            tail = result.second;
            pre->next = head;	//将翻转后的子链拼接上去
            tail->next = next;  //tail的下一个节点应该指向下一个需要翻转的子链的头节点
            pre = tail;
            head = tail->next;
        }
        return hair->next;
    }
};