小黑火车上悟了一晚上汗，身体稍微舒服一些但是很虚，独自逛了平江路吃了蟹黄面，打卡学习狮子林拙政园每一个景点，跟舞花侠吃蟹黄肉汤包苏式生煎晚上逛东方之门的leetcode之旅:25. K 个一组翻转链表-CSDN博客

本文链接：https://blog.csdn.net/qq_37418807/article/details/135837616

小黑用两种方法独立做出一道困难等级题目，思维训练不能停！！好爽啊

小黑代码–递归法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        t = head
        i = 1
        # 确保后面有k个结点
        while t and i < k:
            i += 1
            t = t.next
        if not t:
            return head
        # 开始对后面的结点深度递归，并返回
        after = self.reverseKGroup(t.next, k)
        # 逆转从head到t的链表
        l = head
        r = head.next
        # 开始进行逆转操作
        while l != t:
            temp = r.next
            r.next = l
            l = r
            r = temp
        # 将逆转后的结果回溯
        head.next = after
        return t

在这里插入图片描述

小黑代码–继续死磕非递归法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverse(self, head, k):
        temp = head
        # 计数器
        num = 0
        while temp and num < k:
            temp = temp.next
            num += 1
        # 没有k个结点
        if num < k:
            return head, None
        # 开始逆转序列
        l = head
        r = head.next
        while r != temp:
            t = r.next
            r.next = l
            l = r
            r = t
        head.next = temp
        return l, head

    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        # 设置附加头结点
        add_node = ListNode()
        add_node.next = head
        # 设置指针，指向下一个需要被逆转序列的前置结点
        left = add_node
        # 开始迭代
        while left:
            # 逆转序列的前置结点
            t = left.next
            h, t = self.reverse(t, k)
            # 将处理后的序列链接到链表上
            left.next = h
            left = t
        return add_node.next

在这里插入图片描述

非递归迭代法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    # 翻转链表
    def reverse(self, head):
        # 初始化前驱结点指针
        pre = None
        # 当前结点指针
        cur = head
        while cur:
            t = cur.next
            cur.next = pre
            pre = cur
            cur = t
        return pre


    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        # 额外结点
        add_node = ListNode()
        add_node.next = head
        # 指向需要逆转序列的前驱结点指针
        tail = add_node
        while tail:
            # 初始化指针，计算出子序列的尾指针
            t = tail
            # 寻找尾指针
            # print('========================')
            for i in range(k):
                t = t.next
                if not t:
                    return add_node.next
                # print(t.val)
            # 该子序列起点
            start = tail.next
            # 下一个子序列起点
            next_ = t.next
            # 将该子序列的尾指针的next置空，便于逆转操作
            t.next = None
            # 链接逆转后的序列
            tail.next = self.reverse(tail.next) 
            # print('tail.next:', tail.next, 't', t.val)
            # 子序列头结点start逆转后变成尾结点,将其链接到后面的序列
            start.next = next_
            # 更新tail指针
            tail = start
        return add_node.next