python--lintcode450.K组翻转链表

描述

给定一个链表，一次反转链表 k 的节点并返回其修改后的列表。
如果节点的数量不是k的倍数，那么最后遗漏的节点应该保持原样。
不能更改节点中的值，只能更改节点本身。
只允许使用常量内存。

样例

样例1

输入:
list = 1->2->3->4->5->null
k = 2
输出:
2->1->4->3->5

样例2

输入:
list = 1->2->3->4->5->null
k = 3
输出:
3->2->1->4->5

此题是上一题的加强版，困难级别，要说这一题难也难，指针的问题比较复杂混乱，在面试中很难写出没有bug的答案。要说不难也不难，无非是考验工程能力，细化每个问题。

翻转链表如果不会的同学看我上一篇：https://blog.csdn.net/wenqiwenqi123/article/details/80624929

然后来说一说这一题的思路，两个步骤：

1、检查是否还剩k个数，如果还剩k以上的数，则之后k个数翻转。如果不足k个数，不翻转。

2、翻转这k个数。翻转k个数需要注意，在此段序列之前的那个node的next指针需要调整。

具体请看代码：

class Solution: 
    def reverseKGroup(self, head, k):
        # D->[1->2->3]->[4->5->6]->7 (k = 3)
        # D->[3->2->1]->[6->5->4]->7
        dummy = ListNode(0)
        dummy.next = head # connect dummy node to head D-> head -> .....

        prev = dummy
        while prev:
            prev = self.reverse_next_k_node(prev, k)

        return dummy.next # D-> head'


    def find_kth_node(self, head, k):
        # head -> n1 -> n2 -> ... ->nk
        curr = head
        count = 0
        for i in range(k):
            if curr is None:
                return curr
            curr = curr.next
        return curr


    def reverse(self, head):
        prev = None
        curr = head
        while curr:
            next_node = curr.next
            curr.next = prev
            prev = curr
            curr = next_node
        return prev


    def reverse_next_k_node(self, head, k):
        # head -> n1 -> n2 -> ... ->nk -> nk+1
        # head -> nk -> nk-1 -> ... ->n1 -> nk+1
        n1 = head.next
        nk = self.find_kth_node(head, k)
        if nk is None:
            return None
        nk_plus = nk.next
        # Reverse k nodes
        nk.next = None # separate the nk and nk+1
        nk = self.reverse(n1) # nk->nk-1->nk-2->......n1
        # Connect head and nk -> nk-1 -> ... ->n1,  n1 and nk+1 -> nk+2 ->...
        head.next = nk
        n1.next = nk_plus

        return n1