python K个一组翻转链表 多种解法

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

def reverseKGroup(head, k):
    count = 0
    current = head
    
    # 找到第 k+1 个节点
    while count < k and current:
        current = current.next
        count += 1
    
    # 如果剩余节点数少于 k 个，则不需要翻转
    if count < k:
        return head
    
    # 翻转前 k 个节点
    prev = None
    current = head
    
    for _ in range(k):
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    
    # 递归翻转后续节点，并连接翻转后的头节点
    head.next = reverseKGroup(current, k)
    
    return prev

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

def reverseKGroup(head, k):
    dummy = ListNode(0)  # 创建虚拟头节点
    dummy.next = head
    prev = dummy
    
    while head:
        tail = prev
        
        # 判断剩余节点数是否大于等于 k
        for _ in range(k):
            tail = tail.next
            if not tail:
                return dummy.next
        
        next_group = tail.next
        
        # 翻转当前组的节点
        prev.next = reverseList(head, tail)
        
        # 将翻转后的尾节点连接到下一组的头节点
        head.next = next_group
        
        # 更新指针
        prev = head
        head = next_group
      
    return dummy.next

def reverseList(head, tail):
    prev = None
    current = head
    
    while prev != tail:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    
    return tail

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

def reverseKGroup(head, k):
    dummy = ListNode(0)  # 创建虚拟头节点
    dummy.next = head
    prev = dummy
    
    while head:
        stack = []
        count = 0
        
        # 将当前组的节点入栈
        while head and count < k:
            stack.append(head)
            head = head.next
            count += 1
        
        # 如果剩余节点数少于 k 个，则不需要翻转
        if count < k:
            return dummy.next
        
        # 翻转当前组的节点
        while stack:
            prev.next = stack.pop()
            prev = prev.next
        
        # 将翻转后的尾节点连接到下一组的头节点
        prev.next = head
      
    return dummy.next