手把手带你学算法——K个一组翻转链表（25）

欢迎来到本教程的一篇新文章，我们将学习如何解决LeetCode中的问题25——"K个一组翻转链表"。这是一个有趣且具有挑战性的链表问题，通过学习如何解决它，你将提高你的链表处理技能。

问题描述

题目描述如下：

给定一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

假设我们有一个链表 1 -> 2 -> 3 -> 4 -> 5，并且 k = 2，那么按照题目要求，应该返回 2 -> 1 -> 4 -> 3 -> 5。

解决思路

要解决这个问题，我们需要以每 k 个节点为一组，对链表进行翻转。解决思路如下：

1. 定义两个指针 prev 和 curr，分别指向每组的前一个节点和当前节点。

2. 遍历链表，每次遍历 k 个节点，如果不足 k 个节点，保持不变。

3. 对这 k 个节点进行反转，即将它们之间的指针方向翻转。

4. 更新 prev 和 curr 指针，继续遍历下一组 k 个节点。

5. 重复上述步骤，直到链表的末尾。

Python代码实现

下面是使用Python实现的解决方案代码：

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

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        if not head or k == 1:
            return head

        dummy = ListNode(0)
        dummy.next = head
        prev = dummy
        curr = head
        count = 0

        # 计算链表长度
        while head:
            count += 1
            head = head.next

        # 翻转每一组 k 个节点
        while count >= k:
            for _ in range(k - 1):
                temp = curr.next
                curr.next = temp.next
                temp.next = prev.next
                prev.next = temp
            prev = curr
            curr = curr.next
            count -= k

        return dummy.next

示例

现在让我们看一个示例，演示如何使用这个算法来翻转链表的每一组 k 个节点：

# 创建一个链表：1 -> 2 -> 3 -> 4 -> 5
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)

# 翻转每一组 k 个节点：k = 2
solution = Solution()
new_head = solution.reverseKGroup(head, 2)

# 打印翻转后的链表
while new_head:
    print(new_head.value, end=" -> ")
    new_head = new_head.next

输出应该是：

2 -> 1 -> 4 -> 3 -> 5 ->

结论

通过这篇教程，我们学习了如何解决LeetCode问题25——"K个一组翻转链表"，并提供了相应的Python代码示例。希望这个教程帮助你理解如何处理链表问题，尤其是涉及链表的翻转操作。在接下来的教程中，我们将继续学习更多有关数据结构和算法的知识。感谢阅读！