链表 5.7-链表的k逆序

题目：

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。

给定一个单链表的头指针head,同时给定K值，返回逆序后的链表的头指针。

测试用例：

input: {1，2，3，4，5，6，7，8}，3

output: {3，2，1，6，5，4，7，8}

代码：

递归：

可以理解为在递归的过程中返回翻转后的头结点。举个例子：

在这个例子中，当遍历到尾结点时（Next == nil），直接返回。递归的上一层（假设这一层的结点——尾结点的前一个——记为x）收到返回的结点之后，不对其做任何动作。此时x用x.Next.Next = x; x.Next = nil完成x到尾结点的翻转，然后继续把尾结点向上层传递。最终，我们得到了新的头节点（原来的尾结点）。对于有区间要求（25-分组翻转，92-区间内翻转）的题目，我们可以在递归条件中加一个计数值k。当递归到下一层时，k = k-1。最终以k == 1为边界条件（k == 0时得到的是尾结点的下一个结点），并把下一个区间的第一个结点返回。 

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

class KInverse:
    def inverse(self, head, k):
        # write code here
        def dfs(head, k):
            if k == 1:
                return head, head.next
            newhead, tmp = dfs(head.next, k-1)
            head.next.next = head
            head.next = None
            return newhead, tmp
        
        cnt = 0
        cur = head
        while cur:
            cnt += 1
            cur = cur.next
        
        if cnt < k or cnt == 1 or k <= 1:
            return head

        newhead = ListNode(0)
        newhead.next = head
        pre = newhead
        for i in range(0, cnt/k):
            sub, nxt = dfs(pre.next, k)
            tmp = pre.next
            pre.next.next = nxt
            pre.next = sub
            pre = tmp
        
        return newhead.next

头插法：

要翻转一个链表，我们还可以把后面的结点插到前面。同样假设有3个结点pre，cur，nxt。每次让cur.Next = nxt.Next, nxt.Next = pre.Next, pre.Next = nxt。

class KInverse:
    def inverse(self, head, k):
        # write code here
        cnt = 0
        cur = head
        while cur:
            cnt += 1
            cur = cur.next
        
        if cnt < k or cnt == 1 or k <= 1:
            return head

        newhead = ListNode(0)
        newhead.next = head
        pre = newhead
        cur = head
        for i in range(0, cnt/k):
            for j in range(k-1):
                tmp = cur.next
                cur.next = cur.next.next
                tmp.next = pre.next
                pre.next = tmp
            pre = cur
            cur = cur.next
        
        return newhead.next

迭代：

比较好理解，我们需要三个结点（假设为pre，cur，nxt）。初始时，pre.Next = cur, cur.Next = nxt。每次让cur.Next 指向 pre，完成翻转，然后nxt负责记录下一个需要翻转的结点，三个结点变为：pre = cur, cur = nxt, nxt = nxt.Next。

class KInverse:
    def inverse(self, head, k):
        # write code here
        cnt = 0
        cur = head
        while cur:
            cnt += 1
            cur = cur.next
        
        if cnt < k or cnt == 1 or k <= 1:
            return head

        newhead = ListNode(0)
        newhead.next = head
        start = newhead
        pre = newhead
        cur = head
        nxt = cur.next
        for i in range(0, cnt/k):
            for j in range(k):
                cur.next = pre
                pre = cur
                cur = nxt
                if nxt:
                    nxt = nxt.next
            nxt = start.next
            start.next.next = cur
            start.next = pre
            start = nxt
            if cur:
                nxt = cur.next
        
        return newhead.next