「这是我参与2022首次更文挑战的第16天，活动详情查看：2022首次更文挑战」
[K 个一组翻转链表]
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
进阶：
你可以设计一个只使用常数额外空间的算法来解决此问题吗？ 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例 1：
输入：head = [1,2,3,4,5], k = 2 输出：[2,1,4,3,5] 示例 2：
输入：head = [1,2,3,4,5], k = 3 输出：[3,2,1,4,5] 示例 3：
输入：head = [1,2,3,4,5], k = 1 输出：[1,2,3,4,5] 示例 4：
输入：head = [1], k = 1 输出：[1] 提示：
列表中节点的数量在范围 sz 内 1 <= sz <= 5000 0 <= Node.val <= 1000 1 <= k <= sz
解题思路：
- 本题难度为 困难 但是思路很清晰 相对比较好解
- 递归处理，实际计算和滑动窗口一致，创建一个以k为长度的窗口，然后滑动，如果长度小于k则不动，否则就进行翻转操作。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
slow = fast = head
for i in range(k):
if not fast:return head
fast = fast.next
def reverse(slow,fast):
i,j = None,slow
while j != fast:
t = j.next
j.next = i
i,j = j,t
return i
n = reverse(slow,fast)
slow.next = self.reverseKGroup(fast,k)
return n
执行结果：
[重排链表]
给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln - 1 → Ln 请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → … 不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4] 输出：[1,4,2,3] 示例 2：
输入：head = [1,2,3,4,5] 输出：[1,5,2,4,3]
提示：
链表的长度范围为 [1, 5 * 104] 1 <= node.val <= 1000
解题思路： 1.先判断特殊情况，head为空直接返回 2.用栈弹出的方法，如果没有就进行弹出操作。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reorderList(self, head: ListNode) -> None:
"""
Do not return anything, modify head in-place instead.
"""
if not head:
return head
tmp = []
while head:
tmp.append(head)
head = head.next
res = ListNode(-1)
while tmp:
if len(tmp)>=2:
res.next = tmp.pop(0)
res.next.next = tmp.pop(-1)
res = res.next.next
else:
res.next = tmp.pop(0)
res = res.next
res.next= None
return res
执行结果：
