每K个一组反转链表

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()
        

import java.util.Scanner;

public class Main {
	static class ListNode{
		public int val;
		public ListNode next;
		public ListNode(int val) {
			this.val = val;
		}
	}
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = scanner.nextLine();
		int k = scanner.nextInt();
		String[] strings = string.split(" ");
		ListNode head = new ListNode(-1);
		ListNode tail = head;
		for(String str : strings) {
			ListNode node = new ListNode(Integer.valueOf(str));
			tail.next = node;
			tail = tail.next;
		}
		head = head.next;
		ListNode newHead = solution1(head, k);
		while(newHead != null) {
			if(newHead.next == null) System.out.println(Integer.valueOf(newHead.val));
			else System.out.print(Integer.valueOf(newHead.val) + " ");
			newHead = newHead.next;
		}
	}
	public static ListNode solution1(ListNode head, int k) {
		ListNode dummy = new ListNode(0);
		dummy.next = head;
		head = dummy;
		while(true) {
			head = solution2(head, k);
			if(head == null) break;
				
		}
		return dummy.next;
	}
	public static ListNode solution2(ListNode head, int k) {
		ListNode nk = head;
		for(int i = 0; i < k; i++) {
			if(nk == null) return null;
			nk = nk.next;
		}
		if(nk == null) return null;
		ListNode nkPlus = nk.next;
		ListNode n1 = head.next;
		ListNode pre = null;
		ListNode cur = n1;
		while(cur != nkPlus) {
			ListNode tmp = cur.next;
			cur.next = pre;
			pre = cur;
			cur = tmp;
		}
		head.next = nk;
		n1.next = nkPlus;
		return n1;
	}
}

利用递归的方法最简单：

import java.util.*;
class ListNode{
    int val;
    ListNode next = null;
    ListNode(int val){
        this.val = val;
    }
}
public class reverseKlist{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()){
            String[] str = sc.nextLine().split(" ");
            int k = Integer.valueOf(sc.nextLine());
            ListNode pre = new ListNode(Integer.valueOf(str[0]));
            ListNode head = pre;
            for (int i=1;i<str.length;i++){
                ListNode node = new ListNode(Integer.valueOf(str[i]));
                pre.next = node;
                pre = node;
            }
            pre.next = null;
            head = reverse(head, k);
            while (head != null){
                System.out.print(head.val+" ");
                head = head.next;
            }
        }
    }
    public static ListNode reverse(ListNode head, int k){
        ListNode tmp = head;
        for (int i=1;i<k&&tmp!=null;i++)
            tmp = tmp.next;
        if (tmp == null) return head;
        ListNode Lhead = tmp.next;
        tmp.next = null;
        ListNode newHead = revK(head);
        ListNode newLHead = reverse(Lhead, k);
        head.next = newLHead;
        return newHead;
    }
    public static ListNode revK(ListNode head){
        ListNode tmp = null, pre = null;
        while (head != null){
            tmp = head.next;
            head.next = pre;
            pre = head;
            head = tmp;
        }
        return pre;
    }
}

function LinkList() {
    let Node = function(val) {
        this.val = val;
        this.next = null;
    }
    let head = null;
    let length = 0;
    this.append = function(val) {
        let node = new Node(val);
        let cur
        if (head == null) {
            head = node
        } else {
            cur = head;
            while (cur.next) {
                cur = cur.next
            }
            cur.next = node
        }
        length++
    };
    this.getHead = function() {
        return head
    }
}
let arr = readline().split(' ');
let n = parseInt(readline())
let link = new LinkList()
for(let i = 0;i<arr.length;i++){
    link.append(arr[i])
}
let head = link.getHead();

let arr_temp = [], pNode = head;
while (pNode) {
    arr_temp.push(pNode.val)
    pNode = pNode.next
}
let res = []
while (arr_temp.length>0) {
    let test = arr_temp.splice(0, n)
    if(test.length == n ){
        test.reverse()
    }
    res.push(...test)
}
print(res.join(' '))

/*
思路：写一个反转函数，每次都把相应长度的字符串进行翻转，反转可以用revese方法，不合题意
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String[] str = br.readLine().split(" ");
        int k = Integer.parseInt(br.readLine());
        if(str.length < k)
            for(int i = 0;i<str.length;i++){
                System.out.print(str[i] + " ");
                if(i==str.length-1)
                    System.out.println();
            }
        else{
            int n = str.length/k;
            for(int i = 0;i<n;i++){
                int left = 0 + i*k;
                int right = i*k + k -1;
                while(left < right){//反转
                    String temp = str[left];
                    str[left] = str[right];
                    str[right] = temp;
                    left++;right--;
                }
            }
            for(int i = 0;i<str.length;i++){
                System.out.print(str[i] + " ");
                if(i==str.length-1)
                    System.out.println();
            }
        }
    }
}

确定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))

import java.util.Scanner;

public class Main{
    static class ListNode{
        private int val;
        public ListNode next;
        public ListNode(int val){
            this.val=val;
        }
    }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        //while(in.hasNextLine()){
            String[] nums=in.nextLine().split(" ");
            
            int k=in.nextInt();
            if(nums.length==0) {
                System.out.println();
                //continue;
            }

            if(nums.length==1) {
                System.out.println(nums[0]);
                //continue;
            }
            if(nums.length<2) return;
            ListNode head=new ListNode(0);
            ListNode last=head;
            for(String s:nums){
                last.next=new ListNode(Integer.parseInt(s));
                last=last.next;
            }
            if(k>1){
                reverse(head,k);
            }
            head=head.next;
            while(head.next!=null){
                System.out.print(head.val+" ");
                head=head.next;
            }
            System.out.println(head.val);
        //}
    }
    
    public static void reverse(ListNode head,int k){

        while(isK(head,k)){
            ListNode p=head.next;
            ListNode q=p.next;
            ListNode last=p;
            for(int i=0;i<k-1;i++){
                ListNode tmp=q;
                q=q.next;
                tmp.next=p;
                p=tmp;
            }
            head.next=p;
            last.next=q;
            head=last;
        }
        return;
    }
    
    public static boolean isK(ListNode head,int k){
        for(int i=0;i<k;i++){
            head=head.next;
            if(head==null) return false;
        }
        return true;
    }
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    string s;
    getline(cin,s);
    int k,n=0;
    cin>>k;
    vector<int>num;
    for(int i=0;i<s.size();i++)
    {
        if(isdigit(s[i]))
            n=n*10+s[i]-'0';
        else
        {
            num.push_back(n);
            n=0;
        }
    }
    num.push_back(n);
    for(int i=0;i<num.size()/k;i++)
        reverse(num.begin()+i*k,num.begin()+i*k+k);
    for(int i=0;i<num.size();i++)
        cout<<num[i]<<" ";
    cout<<endl;
    return 0;
}

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    var a = (await readline()).split(" ").map(Number);
    var k = parseInt(await readline());
    if(k>a.length||k<2){
        console.log(a.join(' '))
        return 
    }
    for (let i = 0; i < a.length; i++) {
        if (i % k == 0&&i+k<=a.length) {
            var tmp=a.splice(i,k)
            a.splice(i,0,...tmp.reverse())
        }
    }
    console.log(a.join(' '));
})();

package main

import (
    "fmt"
)

func main() {
    var x int
    arr:=[]int{}
    for{
        _,ok:=fmt.Scan(&x)
        if ok!=nil{
            break
        }
        arr=append(arr,x)
    }
    k:=arr[len(arr)-1]
    arr=arr[:len(arr)-1]
    for l,r:=0,k-1;r<len(arr);l,r=l+k,r+k{
        arr=reverse(l,r,arr)
    }
    for _,x:=range arr{
        fmt.Printf("%v ",x)
    }
}

func reverse(i,j int,arr []int)[]int{
    for i<j{
        arr[i],arr[j]=arr[j],arr[i]
        i++
        j--
    }
    return arr
}