每K个一组反转链表

import sys
def iter_root(root):
    while root:
        yield root
        root = root.next
class ListNode:
    def __init__(self, n):
        self.val = n
        self.next = None
lst = [ListNode(n) for n in ls]
k = int(sys.stdin.readline().strip())
n = int(len(lst) / k)
new_lst = []
if n == 0:
    new_lst = lst
else:
    while m<n:
        for i in reversed(range(m*k, m*k+k)):
            new_lst.append(lst[i])
    if len(lst) % k > 0:
for i, node in enumerate(new_lst):
    if i<len(new_lst)-1:
        node.next = new_lst[i+1]
ans = ''
#print(new_lst)
p_head = new_lst[0]
while p_head:
    ans += str(p_head.val) + ' '
    p_head = p_head.next
print(ans.strip())

class Node(object):
    def __init__(self,val):
        self.val = val 
        self.next = None
        
class Solution(object):
    def __init__(self,array):
        #初始化链表
        self.count = 0
        if not array:
            self.head = None
        temp = None
        for i in array:
            if not temp:
                self.head = Node(i)
                temp = self.head
            else:
                temp.next = Node(i)
                temp = temp.next
            self.count+=1
    def series(self,head):
        #把链表按照题目要求输出
        if not head:
            return None
        res = []
        temp = head
        while temp:
            res.append(temp.val)
            temp = temp.next
        print(' '.join(map(str,res)))
        
    def k_reverse(self,head,k):
        #链表按照每k节点反转一次，思路是每K个节点生成首尾的指针，然后按照首尾指针进行K个节点的翻转
        #每次翻转后的尾节点连向下一段节点，
        #其中下一段节点通过递归的方式来生成
        if head == None&nbs***bsp;head.next == None&nbs***bsp;k<=1:
            return head
        cur = head
        for i in range(k-1):
            cur = cur.next
            if cur == None:
                return head
        next = cur.next
        cur = self.reverse(head,cur)
        head.next = self.k_reverse(next,k)
        return cur
    
    def reverse(self,head,tail):
        #k_reverse的局部函数，用于给定首尾节点进行翻转
        if head == None&nbs***bsp;tail == None:
            return None
        cur = head
        pre = None
        post = None
        while cur != tail:
            post = cur.next
            cur.next = pre
            pre = cur
            cur = post 
        cur.next = pre
        return cur
def main():
    #先获取输入
    #把输入初始化为链表
    #让链表每K个翻转一次
    #输出链表
    in_list = map(int,input().split(" "))
    k = int(input())
    s = Solution(in_list)
    new_head = s.k_reverse(s.head,k)
    s.series(new_head)
main()
        

确定k有几组，然后循环，每组内部再循环，注意奇偶数，cishu = k//2，取左中位数

def reverse(array, left, right, k):
    cishu = k // 2
    while cishu > 0:
        array[left], array[right] = array[right], array[left]
        left += 1
        right -= 1
        cishu -= 1

array = list(map(int, input().split()))
k = int(input())
beishu = len(array) // k
left = 0
right = k-1
for i in range(beishu):
    reverse(array, left, right, k)
    left += k
    right += k

print(" ".join(str(i) for i in array))