国际空间研究组织 | ISRO CS 2016 | 问题 62

本题为有关数据结构的问题。

题目描述

给定一个单向链表和一个整数k，将链表按k个节点进行反转。

例如，如果链表为1->2->3->4->5->6，而k为2，则应该返回2->1->4->3->6->5。

注意：

• 如果节点数不是k的倍数，则最后一部分大小为最小值。
• 如果k>节点数，则不进行任何操作。
• 仅使用常量的额外空间。

函数签名

def reverse_k_nodes(head: Optional[Node], k: int) -> Optional[Node]:

输入

• 单向链表头结点head，head可能为None，单向链表长度不超过1000，每个节点的值在[1, 1000]范围内。

• 整数k(1<=k<=length(链表))

  | 输入格式 | 输入样例1 | 输入样例2 | | -------- | --------- | --------- | | head | 1 -> 2 -> 3 -> 4 -> 5 -> 6| 1 -> 2 -> 3 -> 4 -> 5 -> 6 | | k | 2 | 3 |

输出

将按k大小的子链表进行反转后的链表头结点返回，head可能变化。 head可能为None。

| 输出格式 | 输出样例1 | 输出样例2 | | -------- | --------- | --------- | | head | 2 -> 1 -> 4 -> 3 -> 6 -> 5 | 3 -> 2 -> 1 -> 6 -> 5 -> 4 |

解题思路

首先想到的是利用栈进行操作。即遍历链表，每k个节点就将每个节点压入栈中，然后弹出栈中的元素进行反转。但是本题要求仅能使用常量的额外空间，所以我们要另寻他法。

我们可以直接在原链表上进行操作。对于k个节点，我们将其子链表反转。对于剩余部分，仍保持原来的顺序。最后将每个子链表连接起来即可。

具体操作可以利用链表反转的基本技巧，实现k个节点子链表反转。

代码实现

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


def reverse_k_nodes(head: Optional[ListNode], k: int) -> Optional[ListNode]:
    if not head or k == 1:
        return head

    cur = head
    pre = None

    while cur is not None:
        remains = cur
        count = 0
        while cur is not None and count < k:
            cur = cur.next
            count += 1

        if count == k:
            tail = remains
            for i in range(k):
                temp = remains.next
                remains.next = pre
                pre = remains
                remains = temp

            tail.next = cur
            if head == tail:   
                head = pre
            else:
                pre_tail.next = pre
            pre_tail = tail
            pre = None
        else:
            if pre_tail:
                pre_tail.next = remains
            break

    return head

时间复杂度

• 时间复杂度为 $O(N)$，N为链表长度。

空间复杂度

• 空间复杂度为 $O(1)$， 仅使用常量的空间。