來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/reverse-nodes-in-k-group

題目描述

給你一個連結串列，每 k 個節點一組進行翻轉，請你返回翻轉後的連結串列。

k 是一個正整數，它的值小於或等於連結串列的長度。

如果節點總數不是 k 的整數倍，那麼請將最後剩餘的節點保持原有順序。

進階：

你可以設計一個只使用常數額外空間的演算法來解決此問題嗎？
你不能只是單純的改變節點內部的值，而是需要實際進行節點交換。
 

示例 1：

輸入：head = [1,2,3,4,5], k = 2
輸出：[2,1,4,3,5]
示例 2：

輸入：head = [1,2,3,4,5], k = 3
輸出：[3,2,1,4,5]
示例 3：

輸入：head = [1,2,3,4,5], k = 1
輸出：[1,2,3,4,5]
示例 4：

輸入：head = [1], k = 1
輸出：[1]
提示：

列表中節點的數量在範圍 sz 內
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz

解題思路

主要考察對連結串列的操作，可以分為兩個步驟來進行，首先找到需要翻轉的區間[a,b],由於需要將翻轉後的結果重新連入連結串列，所以需要傳入a的前一個結點和b的後一個結點。第二步，[a,b]的結點翻轉，這裡將[a,b]拆下然後用頭插法進行一次插入就可以了。

程式碼展示

/**
 * 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* reverse(ListNode* fa, ListNode* ch)
    {
        ListNode *pRet = fa->next, *p = fa->next, *q;
        fa->next = ch;
        while(p != ch)
        {
            q = p->next;
            p->next = fa->next;
            fa->next = p;
            p 
 
= q;
        }
        return pRet;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *nHead = new ListNode(-1, head);
        ListNode *q = head;
        ListNode *p = nHead;
        int iCount = 0;
        while(1)
        {
            iCount = 0;
            while(q && iCount < k)
            {
                q = q->next;
                iCount++;
            }
            if(iCount < k)
                return nHead->next;
            else
                p = reverse(p, q); 
              
        }
    }
};

執行結果