leetcode 困难 —— K 个一组翻转链表（简单模拟）

（思路很简单，但需要把思路捋清楚，不然还是会卡）

题目：
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

题解：

我们需要一组一组进行翻转，相当于我们进行一段一段的分开考虑

我们每一段的翻转后，需要哪些有用信息？
需要每一段翻转之后的 首 和 尾
首 用于和前一段相连
尾 用于和后一段相连

还需要注意一个细节，翻转之后的 尾 需要指向下一段的未翻转的 首
因为我们原本指向下一段的未翻转的 首 的点，现在指向了别处
如果翻转之后的 尾 没指向下一段的未翻转的 首，那我们访问不到下一个节点，就完蛋了

每次都将当前这个段和上一段相连，并保存当前这个段，用于和下一段相连

（就这个简单思路，模拟起来花了我一个多小时，服了）
代码如下：

/**
 * 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:
    pair<ListNode*, ListNode*> solve(ListNode* p, int k) {
        int w = 0;
        ListNode* f = p;
        ListNode* p1 = p;
        ListNode* p2;
        ListNode* p3 = NULL;
        while(w < k) {
            p2 = p1;
            p1 = p1 -> next;
            p2 -> next = p3;
            p3 = p2;
            w++;
        }
        f -> next = p1;
        return make_pair(p2, f);
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k == 1) return head;
        ListNode* f = head;
        int flag = 0;
        while(f != NULL) {
            f = f -> next;
            flag++;
        }
        ListNode* res;
        ListNode* p1 = NULL;
        ListNode* p2 = NULL;
        ListNode* pp1;
        ListNode* pp2;
        pair<ListNode*, ListNode*> ppp;
        while(flag >= k) {
            flag = flag - k;
            if(p2 == NULL) f = head;
            else f = p2 -> next;
            ppp = solve(f, k);
            pp1 = ppp.first;
            pp2 = ppp.second;
            if(p1 != NULL && p1 != NULL) {
                p2 -> next = pp1;
            }
            else {
                res = pp1;
            }
            p1 = pp1;
            p2 = pp2;
        }
        return res;
    }
};