每K个一组反转单链表

这是laluladong系列学习的一部分。

同步发表于我的个人站点：每K个一组反转单链表

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

labuladong的解法： https://labuladong.gitee.io/algo/2/17/17/
leetcode官方解法： https://leetcode-cn.com/problems/reverse-nodes-in-k-group/

我把两种解法的代码实现都写在下面的代码里面了。

关于两个教程的一些比较：

1. labuladong的教程相对于leetcode来说更容易理解
2. labuladong的教程说是迭代解法，但实际上还是用到了递归，所以在性能上要比leetcode的解法差一些
3. leetcode的解题思路更具有引导的作用，比如在head节点前面认为创造一个pre节点可以避免特判，虽然labuladong也是这么做的，但是没有明说出来，新手可能不容日get到那个点

整体上来说，建议先看labuladong的教程，实际把代码实现一边，然后再好好看看leetcode官方解法，尤其是解题思路。

leetcode解法中反转部分子链表的地方关于prev节点的处理方法有一点还没理解，在代码中做了注释，如果有了解的大神希望可以通过评论指导我一下

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    ## laluladong 解法(迭代)
    # def reverse(self, head: ListNode, tail: ListNode) -> ListNode:
    #     pre = None
    #     cur = head
    #     nxt = head
    #     while cur != tail:
    #         nxt = cur.next
    #         cur.next = pre
    #         pre = cur
    #         cur = nxt
    #     return pre

    # def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
    #     if head == None:
    #         return head
    #     a = head
    #     b = head
    #     for item in range(k):
    #         if b != None:
    #             b = b.next
    #         else:
    #             return head
    #     newHead = self.reverse(a, b)
    #     a.next = self.reverseKGroup(b, k)
    #     return newHead

    ## 官方解法
    # 翻转一个子链表，并且返回新的头与尾
    def reverse(self, head: ListNode, tail: ListNode):
        prev = tail.next  # 这里给prev赋值为None也可以，不影响结果，但是性能会差，为什么？
        p = head
        while prev != tail:
            nex = p.next
            p.next = prev
            prev = p
            p = nex
        return tail, head

    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        hair = ListNode(0)
        hair.next = head
        pre = hair

        while head:  # 这个循环会反转整个链表，替代了laluladong迭代解法中的递归调用
            tail = pre
            # 查看剩余部分长度是否大于等于 k
            for i in range(k):
                tail = tail.next
                if not tail:
                    return hair.next
            nex = tail.next
            head, tail = self.reverse(head, tail)
            # 把子链表重新接回原链表
            pre.next = head
            tail.next = nex
            pre = tail  # 此时的tail是后面一段子链表的hair（也就是pre）
            head = tail.next
        
        return hair.next