揭开LeetCode难题的秘诀：图解K个一组翻转链表

Android

2023-10-30 11:06:21

K 个一组翻转链表：算法图鉴中的宝石

前言

在算法的奇幻世界中，链表宛如一条蜿蜒的道路，将分散的数据串联成有序的序列。而"K 个一组翻转链表"这道 LeetCode 难题，则考验着我们驾驭链表的技巧和算法思维的敏锐性。

深入链表的奥秘

想象一条由节点构成的链表，每个节点中存放着一个数字。我们的任务是将链表中的节点每 K 个一组进行翻转，同时确保链表整体结构的完整性。

举个例子，如果原链表为 1->2->3->4->5，K=2，那么翻转后的链表应为 2->1->4->3->5。

动态规划的巧妙运用

解决这道难题，我们可以借鉴动态规划的思想。动态规划是一种自底向上的算法策略，它将问题分解为一系列子问题，逐步求解，最终得到最优解。

递归的优雅舞步

在动态规划的基础上，我们引入递归的技巧。递归是一种函数自调用的技术，它将问题划分为更小的子问题，直到这些子问题可以轻松求解。

算法流程的精髓

现在，我们来一步步拆解算法的流程：

设置两个指针：prev 和 next，prev 指向当前子链表的尾节点，next 指向当前子链表的头节点。
循环 K 次，每次将 next 指向的节点移到 prev 节点的前面。
将 prev 和 next 指针分别向后移动一位。
递归调用函数，对剩余的链表进行同样的操作。
返回翻转后的子链表的头节点。

代码示例：

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 not head or k <= 1:
            return head

        prev = None
        next = None
        new_head = None

        while head:
            tail = head
            for i in range(k - 1):
                if not tail.next:
                    break
                tail = tail.next

            if not tail.next:
                break

            next = tail.next
            tail.next = None

            new_head_sub = self.reverse_list(head, prev)
            new_head = new_head if not new_head else new_head_sub
            prev = head
            head = next

        if prev:
            prev.next = head

        return new_head

    def reverse_list(self, head: ListNode, prev: ListNode) -> ListNode:
        if not head:
            return prev

        next = head.next
        head.next = prev
        return self.reverse_list(next, head)