基础知识要求：
Java：方法、while循环、for循环、if else语句
Python： 方法、while循环、for循环、if else语句
题目：
给你链表的头节点 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 <= 50000 <= Node.val <= 1000
思路解析：
- 准备阶段 ：
- 首先，我们需要一个哑节点（dummy node）来简化头节点的处理。哑节点是一个不存储实际数据的节点，它的
next指针指向链表的头节点。这样，我们就可以避免处理头节点翻转时的特殊情况。 - 初始化三个指针：
prev（前一个子链表的末尾节点）、curr（当前子链表的开始节点）和end（当前子链表的末尾节点）。开始时，prev指向哑节点，curr指向头节点。
- 首先，我们需要一个哑节点（dummy node）来简化头节点的处理。哑节点是一个不存储实际数据的节点，它的
- 循环处理阶段 ：
- 在每次循环中，我们首先使用
getKthNode函数找到当前子链表的末尾节点end。如果end是null，说明剩下的节点数不足k个，我们不需要再翻转，直接结束循环。 - 如果
end不是null，说明当前子链表至少有k个节点，可以进行翻转。在翻转之前，我们需要保存下一个子链表的开始节点，即end.next，因为翻转后我们会丢失对它的引用。 - 使用
reverse函数翻转当前子链表。翻转后，curr（原来的开始节点）会变为翻转后的末尾节点，并且它的next指针会指向下一个子链表的开始节点。 - 更新
prev和curr的位置。prev指向curr（翻转后的末尾节点），curr指向下一个子链表的开始节点（即之前保存的end.next）。
- 在每次循环中，我们首先使用
- 结束阶段 ：
- 当循环结束后，我们得到了一个每
k个节点一组翻转后的链表。这个链表的头节点是哑节点的next指针所指向的节点。 - 返回哑节点的
next指针作为结果。
- 当循环结束后，我们得到了一个每
Java代码示例：
java
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
public class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
if (head == null || k <= 1) {
return head;
}
// 创建一个哑节点(dummy node)，简化头节点处理
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode prev = dummy; // 前一个子链表的末尾节点
ListNode curr = head; // 当前子链表的开始节点
while (curr != null) {
// 计算当前子链表的末尾节点
ListNode end = getKthNode(curr, k);
if (end == null) {
// 不足k个节点，无需翻转，直接退出循环
break;
}
// 翻转当前子链表
ListNode nextGroup = end.next; // 下一个子链表的开始节点
end.next = null; // 切断当前子链表与后续链表的连接
prev.next = reverse(curr); // 翻转后的子链表连接到前一个子链表的末尾
curr.next = nextGroup; // 翻转后的子链表的末尾节点指向下一个子链表的开始节点
// 更新指针
prev = curr; // 前一个子链表的末尾节点移动到当前翻转后的子链表的末尾
curr = nextGroup; // 当前子链表的开始节点移动到下一个子链表的开始节点
}
return dummy.next; // 返回修改后的链表头节点
}
// 翻转链表
private ListNode reverse(ListNode head) {
ListNode prev = null;
ListNode curr = head;
while (curr != null) {
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev; // 返回翻转后的头节点
}
// 获取第k个节点
private ListNode getKthNode(ListNode head, int k) {
ListNode curr = head;
for (int i = 0; i < k && curr != null; i++) {
curr = curr.next;
}
return curr;
}
}Python代码示例：
python
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
if not head or k <= 1:
return head
# 创建一个哑节点(dummy node)，简化头节点处理
dummy = ListNode(0)
dummy.next = head
prev = dummy # 前一个子链表的末尾节点
curr = head # 当前子链表的开始节点
while curr:
# 计算当前子链表的末尾节点
end = self.getKthNode(curr, k)
if not end:
# 不足k个节点，无需翻转，直接退出循环
break
# 翻转当前子链表
next_group = end.next # 下一个子链表的开始节点
end.next = None # 切断当前子链表与后续链表的连接
prev.next = self.reverse(curr) # 翻转后的子链表连接到前一个子链表的末尾
curr.next = next_group # 翻转后的子链表的末尾节点指向下一个子链表的开始节点
# 更新指针
prev = curr # 前一个子链表的末尾节点移动到当前翻转后的子链表的末尾
curr = next_group # 当前子链表的开始节点移动到下一个子链表的开始节点
return dummy.next # 返回修改后的链表头节点
# 翻转链表
def reverse(self, head: ListNode) -> ListNode:
prev = None
curr = head
while curr:
next_node = curr.next
curr.next = prev
prev = curr
curr = next_node
return prev # 返回翻转后的头节点
# 获取第k个节点
def getKthNode(self, head: ListNode, k: int) -> ListNode:
curr = head
for _ in range(k):
if curr:
curr = curr.next
else:
return None
return curr