目录
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]提示：
- 链表中的节点数目为
n1 <= k <= n <= 50000 <= 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 的整数倍，则最后剩余的节点保持原有顺序。
