一道经典链表题：路飞 K个一组翻转链表，需要你的 Python 解法！

理解问题：

1. K个一组： 链表被分成K个节点一组。

2. 翻转： 将每个组内的节点反转。

3. 重新连接： 将翻转后的组重新连接起来，形成新的链表。

Python 解法：

def reverse_k_group(head, k):
  """
  反转链表中的每组 K 个节点。

  参数：
    head: 链表的头节点。
    k: 每组的节点数量。

  返回：
    翻转后的链表的头节点。
  """

  # 检查边界条件。
  if not head or k <= 1:
    return head

  # 创建一个临时节点作为新的链表头。
  fake = ListNode(0)
  fake.next = head

  # 初始化当前组的第一个节点和最后一个节点。
  current_group_first = head
  current_group_last = head

  # 遍历链表。
  while current_group_last:
    # 计算当前组的长度。
    group_length = 0
    while group_length < k and current_group_last:
      group_length += 1
      current_group_last = current_group_last.next

    # 如果当前组的长度小于K，则跳出循环。
    if group_length < k:
      break

    # 反转当前组的节点。
    reversed_group_head = reverse_group(current_group_first, current_group_last)

    # 将翻转后的组连接到新的链表上。
    fake.next = reversed_group_head

    # 更新当前组的第一个节点和最后一个节点。
    current_group_first = current_group_last

    # 如果当前组的最后一个节点不为空，则将当前组的最后一个节点的下一个节点连接到翻转后的组的最后一个节点。
    if current_group_last:
      current_group_last.next = reversed_group_head

  # 返回新的链表的头节点。
  return fake.next

def reverse_group(head, tail):
  """
  反转一组链表中的节点。

  参数：
    head: 组的头节点。
    tail: 组的尾节点。

  返回：
    翻转后的组的头节点。
  """

  # 初始化前一个节点、当前节点和下一个节点。
  prev = None
  current = head
  nxt = head.next

  # 遍历组中的节点。
  while current != tail.next:
    # 将当前节点的下一个节点指向前一个节点。
    current.next = prev

    # 更新前一个节点、当前节点和下一个节点。
    prev = current
    current = nxt
    nxt = current.next

  # 返回翻转后的组的头节点。
  return prev

时间复杂度： O(n)，其中n是链表的长度。

空间复杂度： O(1)，因为我们没有使用额外的空间。

示例：

# 创建链表。
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)

# 反转链表中的每组K个节点。
k = 2
reversed_head = reverse_k_group(head, k)

# 打印翻转后的链表。
while reversed_head:
  print(reversed_head.val)
  reversed_head = reversed_head.next

输出：

2
1
4
3
5