450. K组翻转链表

给你一个链表以及一个k,将这个链表从头指针开始每k个翻转一下。
链表元素个数不是k的倍数，最后剩余的不用翻转。

样例

给出链表 1->2->3->4->5

k = 2, 返回 2->1->4->3->5

k = 3, 返回 3->2->1->4->5

解题思路：

1、对链表进行切片，满足条件的存储在node_list中，用tail保存不满足条件的片段。

2、遍历node_list，对其中的链表先翻转然后拼接在一起

3、最后再加上不满足条件的片段

"""
Definition of ListNode
class ListNode(object):
    def __init__(self, val, next=None):
        self.val = val
        self.next = next
"""

class Solution:
    """
    @param head: a ListNode
    @param k: An integer
    @return: a ListNode
    """
    def reverseKGroup(self, head, k):
        # write your code here
        
        cur = head
        #用node_list存储满足条件的链表
        node_list = []
        while cur:
            dummy = ListNode(0)
            pre = dummy
            n = k
            #tail 如果最后的结点片段不满足，tail保存下不满足片段的head，如果刚好切分完，则tail为none
            tail = cur
            #切分链表，存入node_list
            while n:
                pre.next = cur
                pre = pre.next
                cur = cur.next
                n -= 1
                if cur is None:
                    break
            if n==0:
                tail = None
                pre.next = None
                node_list.append(dummy.next)
        
        dummy = ListNode(0)
        pre = dummy
        #对满足条件的链表先翻转，然后再拼接，当前结点指向链表的尾结点
        for i in range(len(node_list)):
            reverse, tmp = self.reverseListNode(node_list[i])
            pre.next = reverse
            pre = tmp
        
        #新链表的最后加上为满足条件的结点
        pre.next = tail
        return dummy.next
        
        
            
    #翻转链表，返回翻转后的链表和尾结点
    def reverseListNode(self, head):
        
        dummy = ListNode(0)
        pre = dummy
        tail = cur = head
        while cur:
            print(cur.val)
            tmp = cur.next
            cur.next = pre.next
            pre.next = cur
            cur = tmp
        
        return dummy.next, tail