Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.


Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5


  • Only constant extra memory is allowed.
  • You may not alter the values in the list’s nodes, only nodes itself may be changed.


# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
# = None

class Solution:
    def reverseKGroup(self, head, k):
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        if head is None:
            return head

        res = None
        prev = None
        p = head

        while True:
            one_node = p
            i = 1
            k_node = p
            while i < k and k_node is not None:
                k_node =
                i += 1
            if k_node is None:
            kone_node =
            curr_node, next_node = one_node,
            for i in range(1, k):
                node =
       = curr_node
                curr_node, next_node = next_node, node
   = kone_node
            if prev is not None:
       = k_node
            if res is None:
                res = k_node
            prev = one_node
            p = kone_node

        return res if res is not None else head