Application scenario of one-way circular linked list

(Joseph U) Joseph's question:
Set n people with numbers 1, 2, 3... N to sit in a circle. It is agreed that the person with number k (1 < = k < = n) will count off from 1, and the person who counts to m will count off from 1, and the person who counts to m will list again, and the next person will count off from 1, and the person who counts to m will list again, and so on until everyone is listed, This produces a sequence of outgoing numbers.
Tip: use a ring linked list of non leading nodes to deal with the Josephu problem; First form a single cycle linked list with n nodes, and then count from 1 from node k. when m is counted, the node is deleted from the linked list, and then count from 1 from the next node of the deleted node until the last node is deleted from the linked list. The algorithm ends.

Joseph's creation of circular linked list

The idea of constructing a one-way circular linked list
Create the first node, let first point to it, and form a ring
Later, when we create a new node, we can add the node to the existing ring linked list

Introduce an auxiliary pointer (variable) current, pointing to the first node
Then, through a while loop variable, the ring linked list can be current.next = first

Analysis of Joseph's out of circle thinking

According to the user's input, a circle out order is generated
n = 5, that is, there are 5 people
k = 1, counting off from the first
m = 2, number 2

• First create an auxiliary pointer (variable) helper, which should point to the last node of the ring linked list in advance.
• Before the child counts off, let the first and helper move k-1 times (in this question, K is just equal to 1, all can be moved)
• When the child counts off, let the first and helper pointers move m-1 times at the same time
• At this time, the child node pointed to by first can be circled
first = first.next
helper.next = first
The node pointed to by first has no reference and will be recycled

Turn out sequence: 2 - > 4 - > 1 - > 5 - > 3

code implementation

bean

```public class JNode {
private Integer num;

private JNode next;

public JNode(Integer num) {
this.num = num;
}

public JNode getNext() {
return next;
}

public void setNext(JNode next) {
this.next = next;
}

public Integer getNum() {
return num;
}

public void setNum(Integer num) {
this.num = num;
}
}
```

One way ring list method

```public class SingleCircleLinkedList {
//Create the first node and set the number to - 1
private JNode first = new JNode(-1);

/**
*/
//check
if(nums<1){
System.out.println("At least one element was passed in");
return;
}
//Create a temporary node to help us build the ring list
JNode current = null;
//Building a one-way circular linked list
for(int i=1;i<=nums;i++){
JNode node = new JNode(i);
if(i==1){
first = node;
first.setNext(first);//Form a ring
current = first; //Let current point to the first child, and the first node cannot move
}else{
current.setNext(node);
node.setNext(first);
current = node;
}
}
}

public void list(){
JNode current = first;
if(current.getNum() == -1){
System.out.println("The current linked list is empty");
}
while(true){
System.out.println("Element number:"+current.getNum());
//Move back
current = current.getNext();
//Description traversal completed
if(current == first){
break;
}

}
}

/**
* The circle order is calculated according to the value entered by the user
* @param startNo Start counting from the node
* @param countNum How many times
* @param num Number of nodes
*/
public void outCircle(int startNo,int countNum, int num){
//Verify the data first
if(first.getNum() == -1|| startNo < 1||startNo>num){
System.out.println("Incorrect input parameters");
}
//First create an auxiliary pointer (variable) helper, and should point to the last node of the ring linked list in advance.
JNode helper = first;
while(true){
if(helper.getNext()==first){
break;
}
helper = helper.getNext();
}
//Before counting, let the first and helper move startNo-1 to the node to start counting
for(int i = 0;i<startNo-1;i++){
first = first.getNext();
helper = helper.getNext();
}
//When counting, let the first and helper pointers move countNum-1 times at the same time, and then circle
while(true){
//When there is only one node in the circle
if(helper == first){
System.out.println("Last loop node:"+first.getNum());
break;
}
for(int i = 0;i<countNum-1;i++){
first = first.getNext();
helper = helper.getNext();
}
//Circle the node first points to
System.out.println("Nodes of this circle:"+first.getNum());
first = first.getNext();
helper.setNext(first);
}

}
}
```

Test code

```public class Test {
public static void main(String[] args) {