以给定大小的组反转链表 | 2套

简介

“以给定大小的组反转链表”是一种操作链表的方法，在每个大小为给定数k的组内反转链表，并将修改后的链表返回。本题也被称为"K个一组翻转链表"，是一道经典的链表操作题目。

本篇介绍两种不同的算法来完成此任务，分别为递归法和迭代法。

算法1：递归法

递归法是一种将问题分割成小问题逐步解决的方法，这种方法通常使用函数自身来实现。对于反转链表问题，可以将链表分为k个节点一组，对于每组节点进行反转，然后将子链表合并起来。

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        curr = head
        count = 0
        while curr and count != k:  # 找到第k+1个节点
            curr = curr.next
            count += 1
        if count == k:  # 如果找到了，将当前组反转
            curr = self.reverseKGroup(curr, k)
            while count > 0:
                tmp = head.next
                head.next = curr
                curr = head
                head = tmp
                count -= 1
            head = curr
        return head

算法2：迭代法

迭代法是一种使用循环的方式，在每次循环中改变链表，直到整个链表被反转。对于本题，可以用一个指针prev表示当前节点的前一个节点，用一个指针tail表示当前组的尾节点，用一个指针next表示当前节点的下一个节点。对于当前组的反转，可以采用普通的链表反转方法。

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        prev = dummy
        while head:
            tail = prev
            for i in range(k):
                tail = tail.next
                if not tail:  # 不足k个节点，不反转，直接返回答案
                    return dummy.next
            next_node = tail.next
            head, tail = self.reverse(head, tail)  # 反转前k个节点
            prev.next = head
            tail.next = next_node
            prev = tail
            head = tail.next
        return dummy.next
    
    def reverse(self, head: ListNode, tail: ListNode) -> List:
        prev = tail.next
        curr = head
        while prev != tail:
            next_node = curr.next
            curr.next = prev
            prev = curr
            curr = next_node
        return tail, head

以上就是本题的两个解法，递归法和迭代法。对于这道题目，采用具体哪一种方法可以按照自己的喜好选择。