leecode25 k个一组翻转链表

题目：

给你一个链表，每k个节点一组进行反转，请你返回反转后的链表。
k是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是k的整数倍，那么请将最后剩余的节点保持原有顺序。
示例：

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

思路一：

1、先将给定的链表存放到列表中去；
2、根据k的值进行切片、反转；
3、建立链表

代码：

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

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        if head == None:
            return head
        if k == 1:
            return head
        
        temp_list = []
        res = list1 = ListNode(0)
        point = head
        while point:
            temp_list.append(point.val)
            point = point.next
        if len(temp_list) < k:
            return head
        times = len(temp_list) // k
        for i in range(1, times + 1):
            temp = temp_list[(i - 1) * k: i * k]
            temp.reverse()
            for l in temp:
                list1.next = ListNode(l)
                list1 = list1.next
        i = times 
        if  len(temp_list) // k:
            temp = temp_list[i * k:]
            for l in temp:
                list1.next = ListNode(l)
                list1 = list1.next
        return res.next

结果：

执行用时 :72 ms, 在所有 Python3 提交中击败了70.99% 的用户
内存消耗 :15.3 MB, 在所有 Python3 提交中击败了5.15%的用户

思路二：（栈）这个速度简直太快了

1、我们把k个数压入栈中，然后弹出就是翻转的；
2、剩下的链表个数不够k个，将已翻转的部分与剩下链表连接

# Definition for singly_linked list
# class ListNode:
#		def _init__(self, x):
#			self.val = x
#			self.next = None

class Solution:
	def reverseKGroup(self, head,  k):
		dummy = ListNode(0)
		p = dummy
		while True:
			count = k
			stack = []
			tmp = head
			while count and tmp:
				stack.append(tmp)
				tmp = tmp.next
				count -= 1
			# 当剩下的链表个数不够k时跳出循环
			if count:
				p.next = head
				break
			# 翻转
			while stack:
				p.next = stack.pop()
				p = p.next
			# 将剩下链表连接
			p.next = tmp
			head = tmp
		return dummy.next

结果：

执行用时 :68 ms, 在所有 Python3 提交中击败了84.87% 的用户
内存消耗 :14.4 MB, 在所有 Python3 提交中击败了11.77%的用户

思路三：

递归

代码：

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

class Solution:
	def reverseKGroup(self, head, k):
		cur = head
		count = 0
		while cur and count != k:
			cur = cur.next
			count += 1
		if count == k:
			cur = self.reverseKGroup(cur, k)
			while count:
				tmp = head.next
				head.next = cur
				cur = head
				head = tmp
				count -= 1
			head = cur
		return head		

结果：

执行用时 :80 ms, 在所有 Python3 提交中击败了40.05% 的用户
内存消耗 :14.7 MB, 在所有 Python3 提交中击败了10.66%的用户