[python]Leetcode25-Reverse Nodes in k-Group

Description：
Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
Example:
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
Note:
Only constant extra memory is allowed.
You may not alter the values in the list’s nodes, only nodes itself may be changed.，

注意题目的要求，末尾不足k个的时候无需翻转，而且不能只改变原链表中的值。

法一：非递归求解

思路：先把链表转换为list，再依次k翻转（最后若无k个不翻转）得到与结果各值相符的新list，最后转换为链表即可。
需要自行编写由list转换为链表的函数，而ListNode类oj已自行定义，不能修改或注释。

# 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
        """
        if not head or not k:
            return None
        idx = 0
        num = []
        result = []
        t = head
        while head:
            num.append(head.val)
            head = head.next
        # 特殊情况：k大于链表长度时，直接返回原链表
        if k>len(num):
            return t
        while idx < len(num):
            if idx + k <=len(num):
                lst = (num[idx:idx + k])[::-1]
            elif idx + k > len(num):
                lst = (num[idx:])
            idx += k
            for i in lst:
                result.append(i)
        return self.list_2_LinkNode(result)
    
    def list_2_LinkNode(self, array):
        tem_node = ListNode(None)
        node = ListNode(None)
        for i in array:
            # 判断val是否为空，最后返回头结点node
            if tem_node.val==None:
                tem_node.val = i
                node = tem_node
            else:
                tem_node.next = ListNode(i)
                tem_node = tem_node.next
        return node
        

法二：递归求解

从原链表中依次翻转k个元素，再对剩下的部分递归处理：

# 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):
        current = head
        count = 0
        while current and count!= k:
            current = current.next
            count += 1
        if count == k:
            current = self.reverseKGroup(current, k)
            while count > 0:
                temp = head.next
                head.next = current
                current = head
                head = temp
                count -= 1
            head = current
        return head