以给定大小的组反转单个链接列表 | 套装3

在这个题目中，我们需要实现一个函数，将给定大小的组反转单个链接列表。

问题描述

给定一个单向链表和一个整数k，你需要将链表中的每个k个连续的节点组进行反转并返回反转后的链表。

如果链表的节点数不是k的倍数，那么需要将最后剩余的节点保持原样。

例如，给定这个链表：1->2->3->4->5

当k=2时，应当返回: 2->1->4->3->5

当k=3时，应当返回: 3->2->1->4->5

实现思路

这种题目一般需要使用到链表的操作，我们需要先遍历链表，然后在每个需要反转的组中，对链表进行反转操作。

具体步骤：

1. 定义一个变量 group_tail，用来表示上一个组的尾节点，同时在遍历链表时需要将链表分为若干组。
2. 遍历链表，遇到分组的节点时，将该节点与上一个组的尾节点进行连接。
3. 反转每个组内的节点，注意要定义一个变量 group_head 表示组的头节点，在反转之前需要将其记录下来。
4. 维护一个新的链表头和链表尾，然后将每个组反转后的链表与新链表进行连接。

代码实现

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseKGroup(head: ListNode, k: int) -> ListNode:
    if not head or k == 1:
        return head

    new_head = None
    new_tail = None

    group_head = head
    group_tail = None

    while group_head:
        count = 0

        p = group_head
        while count < k and p:
            p = p.next
            count += 1

        if count == k:
            # 反转当前组内的节点
            curr = group_head
            prev = None

            while curr != p:
                nxt = curr.next
                curr.next = prev
                prev = curr
                curr = nxt

            # 设置新的链表头和链表尾
            if not new_head:
                new_head = prev
                new_tail = group_head
            else:
                new_tail.next = prev
                new_tail = group_head

            # 更新上一个组的尾节点
            group_head.next = p
            if group_tail:
                group_tail.next = new_head

            group_tail = new_tail

            # 继续遍历链表
            group_head = p
        else:
            break

    if not new_head:
        return head
    return new_head

时间复杂度

这个算法的时间复杂度为 $O(N)$，其中 $N$ 为链表的长度。

参考资料

• LeetCode 25. Reverse Nodes in k-Group