25. Reverse Nodes in k-Group

今天份的困难题

文章目录

题目
分析
代码

题目

给定一个链表，一次反转链表k个节点，并返回修改后的链表。
其中k是正整数，如果剩下链表的长度不足k的话，返回原来的样子

例子：

Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

分析

对于反转链表的题目已经做了不少了，这题算是普通链表的升级版，主要就是分析相比于普通的链表我们需要多知道哪些信息。

以下面的链表为例，k=2，1->2->3->4->5

首先我们肯定需要用到dummy，dummy.next = head，用来储存我们需要返回的值。

首先，我们需要判断这个链表的节点满足我们反转的要求，令r为我们需要反转部分的第一个节点，如果它往后走k个节点始终没有走到空节点的话，那么就满足反转的条件，而r节点同时也走到了下一个需要反转部分的开始节点。

首先我们从第一部分开始反转，如果l同样是需要反转部分的开始节点，令pre, cur= l, l.next即可，然后就是标准的反转过程，如果k=2的话，反转两个节点，就是进行1次。

那么，现在的链表为：

dummy->1<- (-> )2 3->4->5

然后pre节点指向2，cur节点指向3，我们要将不同的部分的反转链表连起来，所以我们需要一个变量tail记录上一个反转链表的尾部，在开始部分的时候tail = head，所以有tail.next = pre，然后更新tail，所以tail = l，最后更新l成为下一段链表的起始点，l=r

因此，现在的链表为：
dummy -> 2 -> (<-)1 3->4->5

可以看到，这时候1节点是指向2的，但是1节点是tail节点，因此如果下一段还是反转的链表，因为tail.next = pre，会重新进行指向。

但是如果下一段不长度够k的话，那么tail应该指向l

代码

我们可以用while循环来进行，那么条件就是当l存在的时候，因为涉及l.next的操作。

所以代码为：

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

class Solution(object):
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        dummy = tail = ListNode(0)
        l = r = dummy.next = head
        
        while l:
            count = 0
            while r and count<k:
                count+=1
                r = r.next
            pre, cur = l, l.next
            if count==k:
                for _ in range(k-1):
                    temp = cur.next
                    cur.next = pre
                    pre = cur
                    cur = temp
                tail.next = pre
                tail = l
                l = r
            else:
                break
        tail.next = l
        return dummy.next

中间的等式可以连起来写

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

class Solution(object):
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        dummy = tail = ListNode(0)
        l = r = dummy.next = head
        while l:
            count = 0
            while r and count<k:
                count+=1
                r = r.next
            pre, cur = l, l.next
            if count==k:
                for _ in range(k-1):
                    cur.next, pre, cur = pre, cur, cur.next
                tail.next, tail, l = pre, l, r
            else:
                break
        tail.next = l
        return dummy.next

来源：CSDN

作者：qq_42024783

链接：https://blog.csdn.net/qq_42024783/article/details/104300152

标签

链表