# LeetCode 25: a set of reverse linked list for each k -- xiaohongshu 2019 technical examination paper for Campus Recruitment

Keywords: Java less

## 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:

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

1 2 3 4 5
2

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)
{
}
```
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(" ");
//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;
}
//Reverse list per 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)
{
//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)
}
ListNode next=currentNode.next;
//Reverse local list
return currentNode;
}

//Write a local function with the head and tail node reversed
public static ListNode reverse(ListNode head, ListNode tail)
{
ListNode pre=null;
ListNode next=null;
while(pre!=tail)
{