空间复杂度 O(1) 解决力扣的困难算法：k个一组翻转链表

题目：给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

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

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

提示：

• 链表中的节点数目为 n

• 1 <= k <= n <= 5000

• 0 <= Node.val <= 1000

---

这个题比较复杂，本文介绍一个易于理解的方法，那就是遍历整个链表，每找到第 K 个区间，就断开该区间的两端箭头，在区间内进行反转操作。反转完成后，再分别连接区间两端的箭头，这样能让区间的首尾结点指向正确的位置。

算法步骤：

1. 检查特殊情况：如果链表为空或只有一个节点，或者 k 等于 1，那么不需要翻转，直接返回原链表的头节点。

2. 创建虚拟头节点：为了避免在翻转时处理头节点的特殊情况，我们可以创建一个虚拟头节点 dummyHead，它的 next 指向原链表的头节点。

3. 翻转每 k 个节点：遍历链表，每 k 个节点进行一次翻转。

4. 更新指针：在每次翻转后，更新 pre 和 end 指针，以便进行下一组 k 个节点的翻转。

5. 处理剩余节点：如果节点总数不是 k 的整数倍，最后剩余的节点不需要翻转，直接连接到翻转后的链表后面。

6. 返回结果：返回虚拟头节点的下一个节点，即修改后的链表的头节点。

复杂度分析：

• 时间复杂度：O (n)，其中 n 是链表的长度。需要遍历整个链表，并且每 k 个节点进行一次翻转。

• 空间复杂度：O (1)，只使用了常数级别的额外空间。

我的 Java 代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        
        if(head==null || head.next==null || k==1){
            return head;
        }

        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode end = dummyHead;  //翻转区间的末尾结点，初始为虚拟头结点
        ListNode pre = dummyHead;  //翻转区间的前一个结点，初始为虚拟头结点
        
        // 翻转每 k 个节点
        while(end != null){
            for(int i=0; i<k; i++){ // 每次移动k步，走到区间的尾结点
                end = end.next;
                if(end == null){   // 不足 k 个节点，结束翻转
                    return dummyHead.next;
                }
            }
            // 开始翻转区间
            ListNode groupNext = end.next; // 存储下一个区间的起点
            ListNode left = pre.next;      // 左指针位于区间第一个结点
            ListNode right = left.next;    // 右指针位于区间第二个结点
            ListNode start = left;         // 存储区间的第一个结点
            // 断开区间两端的箭头
            pre.next = null;
            end.next = null;
            // 使用左右指针，翻转区间
            while(right!=null){
                ListNode t = right.next;
                right.next = left;
                left = right;
                right = t;
            }
            // 连接区间两端的箭头
            pre.next = end;
            start.next = groupNext;
            // 移动指针到翻转区间后的尾结点
            pre = start;
            end = start;
        }
        return dummyHead.next;
    }
}