目录

1.思路：

2.解题方法：

3.复杂度：

4.Code

---

题目：

给你链表的头节点 head ，每 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]

提示：

• 链表中的节点数目为 n
• 1 <= k <= n <= 5000
• 0 <= Node.val <= 1000

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

1.思路：

使用虚拟头节点 dummy 方便处理边界情况。

然后，遍历链表，每次找到待翻转区间的前驱节点 prev 和尾节点 tail。

判断剩余节点数量是否大于等于 k，

若是，则翻转当前区间并接入到原链表中；

若不是，则说明剩余节点数量不足 k 个，不需要翻转。

2.解题方法：

         定义一个辅助函数 reverse，用于翻转给定区间的链表，并返回翻转后的头尾节点。在主函数中，遍历链表，每次找到待翻转区间的前驱节点和尾节点，调用 reverse 函数进行翻转，并将翻转后的区间接入到原链表中。

3.复杂度：

        时间复杂度：O(N)，其中 N 是链表的长度。这是因为我们需要遍历整个链表，并且每次处理的区间长度最多为 k，因此总的时间复杂度为线性的。

        空间复杂度：O(1)。

4.Code

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        // 创建一个虚拟头节点，方便处理边界情况
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        ListNode prev = dummy; // 指向当前待翻转区间的前驱节点
        while (head != null) {
            ListNode tail = prev; // 指向当前待翻转区间的尾节点
            
            // 判断剩余节点数量是否大于等于 k
            for (int i = 0; i < k; i++) {
                tail = tail.next;
                if (tail == null) return dummy.next; // 剩余节点数量不足 k 个，不需要翻转
            }
            
            // 待翻转区间的下一个节点
            ListNode nextGroup = tail.next;
            
            // 翻转当前区间
            ListNode[] reversed = reverse(head, tail);
            head = reversed[0];
            tail = reversed[1];
            
            // 将翻转后的区间接入到原链表中
            prev.next = head;
            tail.next = nextGroup;
            
            // 更新 prev 和 head，准备翻转下一个区间
            prev = tail;
            head = tail.next;
        }
        
        return dummy.next;
    }
    
    // 辅助函数：翻转给定区间的链表，并返回翻转后的头尾节点
    private ListNode[] reverse(ListNode head, ListNode tail) {
        ListNode prev = tail.next;
        ListNode curr = head;
        while (prev != tail) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return new ListNode[]{tail, head};
    }
}

        这段代码实现了将给定链表每 k 个节点一组进行翻转的功能。具体来说，对于给定的链表头节点 head 和正整数 k，函数会将链表中每 k 个节点进行翻转，并返回修改后的链表头节点。

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