25. Reverse Nodes in k-Group (Python)

25. Reverse Nodes in k-Group

Hard

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.

Example:

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

Note:

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

 

 

笔记：

需要用到的关键变量，

pre_node上一次翻转完成后的尾结点

front, tail 需要翻转的新链的头节点和尾结点

每次需要翻转的新链的头节点，需要进行front.next = None

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        if k <= 1:
            return head
        rlt = ListNode()
        front, tail = head, None
        pre_node = rlt
        found_head = False
        while front:
            cnt = 1
            tail = front
            while tail.next and cnt < k:
                tail = tail.next
                cnt += 1
            if cnt == k:
                pre_node.next = tail
                next_head = tail.next
                tail.next = None
                cur = front
                cur_next = cur.next
                cnt = 1
                cur.next = None
                while cnt < k:
                    if cur_next.next:
                        cur_next_next = cur_next.next
                        cur_next.next = cur
                        cur = cur_next
                        cur_next = cur_next_next
                    else:
                        cur_next.next = cur
                    cnt += 1
                pre_node = front
            else:
                pre_node.next = front
                break
            front = next_head
        
        return rlt.next