Title Description

A list is given. Each k nodes are flipped and the flipped list is returned. K is a positive integer whose value is less than or equal to the length of the list. If the total number of nodes is not an integral multiple of K, the remaining nodes will remain in the original order.

Explain:

1. You need to define your own linked list structure and save the input data to your linked list;
2. You can't just change the internal values of nodes, but you need to actually exchange nodes;
3. Your algorithm can only use constant extra space.

Input description

The first line of input is the value of the linked list
The second line of input is the value of K, which is an integer greater than or equal to 1

The input form is:
1 2 3 4 5
2

Output description

When k = 2, it should output:
2 1 4 3 5

When k = 3, it should output:
3 2 1 4 5

When k=6, it should output:
1 2 3 4 5

Example

input

1 2 3 4 5
2

output

2 1 4 3 5

Title Analysis

I read the problem wrong at the beginning and it has been unable to pass. I think it is k nodes before inversion. The topic describes that each K node is a group for inversion. So it is divided into the following steps:

1. The list is divided into n/k groups with k nodes in each group;
2. Each group was reversed internally;
3. The inverted segmented list with k nodes is connected;

So the hardest part is the connection between the inversion function and the inversion.
4. The reverse function is as follows:

 ListNode pre=null;
        ListNode next=null;
        while(pre!=tail)
        {
            next=head.next;
            head.next=pre;
            pre=head;
            head=next;
        }

1. Connect as shown in the figure
   
   This picture is from fly ABCD Zhang, which describes the connection process very well.

Code

The Java code is as follows:

import java.util.Scanner;
 
public class Main {
    //Define Node node
    static class ListNode
    {
        public int val;
        public ListNode next =null; 
        public ListNode(int val) {
            this.val = val;
        }
    }
 
    public static void main(String[] args) 
    {
        //1. Get input information
        Scanner scanner=new Scanner(System.in);
        String string =scanner.nextLine();
        int k=scanner.nextInt();
        String[] strings=string.split(" ");
        //2. Create a header node
        ListNode head=new ListNode(0);
        ListNode tail=head;
        //3. Change the input string into a linked list node
        for(String str : strings)
        {
            ListNode newNode=new ListNode(Integer.valueOf(str));
            tail.next=newNode;
            tail=tail.next;
        }
        head=head.next;
        //Reverse list per k
        ListNode node =reverseGroup(head,k);
        while(node!=null)
        {
            System.out.print(node.val+" ");
            node=node.next;
        }
    }
    //Continuously take k pieces for turning, if not enough, return directly, end
    public static ListNode reverseGroup(ListNode head, int k) 
    {
        if(head==null||head.next==null||k<=1)
            return head;
        ListNode currentNode=head;
        //Get the first and last nodes of k elements
        for(int count =1;count<k;count++)
        {
            currentNode=currentNode.next;
            //If it's not enough, go straight back
            if(currentNode==null)
                return head;
        }
        ListNode next=currentNode.next;
        //Reverse local list
        reverse(head,currentNode);
        head.next=reverseGroup(next,k);
        return currentNode;
    }
 
    
    //Write a local function with the head and tail node reversed
    public static ListNode reverse(ListNode head, ListNode tail) 
    {
        if(head==null||head.next==null)
            return head;
        ListNode pre=null;
        ListNode next=null;
        while(pre!=tail)
        {
            next=head.next;
            head.next=pre;
            pre=head;
            head=next;
        }
        return pre;
    }
}