【LeetCode刷题（困难程度）】25. K 个一组翻转链表

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

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

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

示例：

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

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

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

说明：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：参考标答。过几天再来捋一下。(第二天来弄好的 全新注释版本)
主要注意的点是：
1.我们首先要保存子链表在原来链表中的前一个节点pre以及后一个节点next，因为翻转之后的瞬间是暂时丢失的。
2.翻转完毕后，原来翻转前的头节点head和尾部节点tail都反了，所以我们需要获得翻转后的链表头部和尾部。
3.根据得到的子链表头部和尾部，以及备份的pre以及后一个节点next，就可以将子链表重新接回去。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* pre = dummyHead;//保存子链表的前一个节点

        while(head)
        {
            ListNode* tail = pre;
            //查看剩余部分长度是否大于等于k
            for(int i = 0;i < k;++i)
            {
                tail = tail->next;//将tail置于待翻转链表的尾部
                if(!tail)
                { 
                    return dummyHead->next;
                }
            }

            ListNode* next = tail->next;
            pair<ListNode*, ListNode*> result = reverseList(head, tail);
            head = result.first;//head总是指向翻转后子链表的头部
            tail = result.second;

            //把子链表重新接回原链表
            pre->next = head;
            tail->next = next;

            pre = tail;//pre更新为翻转链表之后的尾部
            head = tail->next;//head为下一个待翻转链表的开始位置
        }
        return dummyHead->next;
    }

//翻转一个子链表 并且返回新的头和尾
    pair<ListNode*, ListNode*> reverseList(ListNode* head, ListNode* tail)
    {
        //pre也可以设置成null 那么37 和38行的代码就必须加上去了
        ListNode* pre = tail->next;//pre保存的是翻转后节点应该正确连接的位置
        ListNode* cur = head;
        while(pre != tail)
        {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return {tail, head};
    }
};

递归版本：
分析
大致过程可以分解为
1、找到待翻转的k个节点（注意：若剩余数量小于 k 的话，则不需要反转，因此直接返回待翻转部分的头结点即可）。
2、对其进行翻转。并返回翻转后的头结点（注意：翻转为左闭右开区间，所以本轮操作的尾结点其实就是下一轮操作的头结点）。
3、对下一轮 k 个节点也进行翻转操作。
4、将上一轮翻转后的尾结点指向下一轮翻转后的头节点，即将每一轮翻转的k的节点连接起来。

作者：reedfan
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/di-gui-java-by-reedfan-2/

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) 
    {
        if(head == nullptr || head->next == nullptr)
        {
            return head;
        }
        ListNode* tail = head;
        for(int i = 0;i < k;++i)
        {
            //剩余数量小于k的话，则不需要翻转
            if(tail == nullptr)
                return head;
            tail = tail->next;//tail就绪
        }
        

        ListNode* newHead = reverseList(head,tail);//注意语义
        head->next = reverseKGroup(tail,k);
        return newHead;
    }
        
    //翻转一个子链表 语义约定为左闭右开区间
    ListNode* reverseList(ListNode* head, ListNode* tail)
    {
        ListNode* pre = nullptr;//pre保存的是翻转后节点应该正确连接的位置
        ListNode* cur = head;
        while(cur != tail)
        {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};