以给定大小的组反转单向链表 |第 4 组(空间高效的方法)

本文介绍了一种空间高效的方法来实现将单向链表按给定大小进行反转的操作。该算法时间复杂度为 O(n)，空间复杂度为 O(1)。

算法步骤

1. 定义一个头结点 head，并将其指向原链表的头结点
2. 定义一个指向当前遍历节点的指针 cur，以及一个指向反转后链表的尾节点的指针 tail，初始值都为头结点
3. 从头结点开始遍历原链表，每遍历到给定的大小 k 个节点就进行反转操作，具体过程如下：
   • 定义一个指向要反转的节点的指针 prev，初始值为反转后链表的下一个节点
   • 循环 k 次，将每个节点插入到反转后链表的头部，直到遍历完 k 个节点或到达原链表的结尾
   • 将 tail 指向反转后链表的尾节点，将 cur 指向下一个要反转的节点，再将 prev 指向 cur
4. 返回头结点 head 的下一个节点即为反转后的链表头部

代码实现

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        if not head or k == 1:
            return head
        # 定义头结点
        dummy = ListNode(0)
        dummy.next = head
        tail = dummy
        cur = head
        while cur:
            # 记录反转前的节点位置
            prev = tail.next
            i = 0
            # 找到下一组节点的开始位置
            while cur and i < k:
                cur = cur.next
                i += 1
            # 如果找到了下一组节点，执行反转操作
            if i == k:
                # 反转操作
                for j in range(k-1):
                    # 将 cur 插入到反转后链表的头部
                    next_node = prev.next
                    prev.next = cur.next
                    cur.next = tail.next
                    tail.next = cur
                    cur = next_node
                # 更新 tail 和 prev 的位置
                tail = prev
                prev = cur
        return dummy.next

总结

该算法通过遍历原链表并进行反转操作，将时间复杂度控制在 O(n) 的同时，通过只使用常量级别的额外空间来实现空间效率的提升。