# Linked list of data structure

Posted by kannu on Wed, 09 Mar 2022 14:19:21 +0100

One day, the little prince was fascinated by the game of queuing. There were 10 toys numbered 1-10 placed in order on the table. Now the little prince wants to place them according to his preferences. The little prince selects a beautiful toy from among them and puts it in the front of all the toys. It is known that he has selected a total of M times. Each time, he selects the toy with label X and puts it in the front to find the toy label after placement.

Given a set of inputs, M=8, a total of 8 times are arranged, and the sequence of these 8 times is 9, 3, 2, 5, 6, 8, 9, 8. Find the number sequence of the final toy.

Process:

3. Realize the insertion operation of linked list

4. Output the ordered linked list

```import java.util.Scanner;

public class Single linked list {

static class Node{
int data;
Node next;

Node(int data){
this.data = data;
}
}//Member class, table node

static void init() {
for(int i = 1; i <= 10; i++) {
x = (x.next = new Node(i));
//			x.next = new Node(i);
//			x = x.next;
x.next = null;
}
}

//Delete node
static void del(int x) {
Node Befor = head;//Store a node precursor to facilitate the deletion of elements
for(Node T = head.next; T != null; T = T.next) {
if(T.data == x) {//Number of found to delete
Node temp = T;//Temporary node save node
Befor.next = T.next;//Delete node from linked list
return;//End function after deletion
}
Befor = T;
}
}

static void insert(int x) {
Node temp = new Node(x);
}

static void show(int x) {
//System.out.println("this is the" + x + "operation");
for(Node T = head.next; T != null; T = T.next) {
System.out.print(T.data + " ");
}
System.out.println();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
int N;
Scanner in = new Scanner(System.in);
init();
//show(0);
N = in.nextInt();

for(int i = 1; i <= N; i++) {
int x = in.nextInt();
del(x);
insert(x);
show(i);
}

}

}
```

Joseph Ring problem

There are n people sitting around the round table. Now start counting from the person at a certain position k(1 ≤ k ≤ n), and the person who counts to m will stand out. The next person, that is, the person in the original position m+1, starts counting from 1 and then counts to M. Repeat until everyone stands up. Try to design a program to find out the sequence of these n people.

• Requirement 1: use circular linked list to solve the problem
• Circular list method: simulation method can be used
• Requirement 3: the definition and usage of circular linked list class can not be used

Analysis: it is almost the same as the previous one, except that the end node points to the head node to form a circular linked list.

```import java.util.Scanner;

public class Circular linked list {
static class Node{
int val;
Node next;
Node(int val){
this.val = val;
}
}

public static void main(String[] args) {
int N, M, K; //n people count off from the k-th position and get out of the line when they count to m
Scanner in = new Scanner(System.in);
N = in.nextInt();
K = in.nextInt();
M = in.nextInt();

Node head = new Node(1);//The head nodes are listed separately to facilitate the formation of a circular linked list

for(int i = 2; i <= N; i++) {
x = (x.next = new Node(i));
}//At this point, x points to the end node

//Find the starting point of counting off
for(int i = 1; i < K; i++) {
x = x.next;//At this point, x points to the k-1 node
}

//Count off
while(x != x.next) {//Stop when there is only one node left
for(int i = 1; i < M; i++) {
x = x.next;
}//At this point, x points to the previous node to delete
System.out.println(x.next.val + " ");
x.next = x.next.next;//Delete node
}
//Output the last node value
System.out.println(x.val);

}

}
```

The same as the single linked list, it is realized with a two-way linked list.

The point is that the node has two pointer fields: next and before. Next points to the next node of the node, and before points to the previous node of the node. X.next Befor = x, which forms a two-way. In the little prince problem, when doing so, when deleting a node, you don't have to save the precursor node in a new node, and you can find it directly.

```import java.util.Scanner;

public class Bidirectional linked list {
static class Node{
int data;
Node next;
Node befor;
Node(int data){
this.data = data;
}
}

static void init() {
for(int i = 1; i <= 10; i++) {
x.next = new Node(i);//Establish a two-way linked list
x.next.befor = x;
x = x.next;
}
x.next = null;
}

//Delete node
static void del(int x) {
for(Node T = head.next; T != null; T = T.next) {
if(T.data == x) {//Found deleted node
T.befor.next = T.next;//Remove node x from the linked list
T.next.befor = T.befor;//Although deleted, the left and right pointers of T also point to the previously pointed node
return;//After deleting the node, end the function
}
}
}

static void insert(int x) {
Node temp = new Node(x);
temp.next.befor = temp;
temp.befor = head;//The next before of the header node also points to the header node. In this question, you can write or not
}

static void show(int x) {
//System.out.println("this is the" + x + "operation");
for(Node T = head.next; T != null; T = T.next) {
System.out.print(T.data + " ");
}
System.out.println();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
int N;
Scanner in = new Scanner(System.in);
init();
//show(0);
N = in.nextInt();

for(int i = 1; i <= N; i++) {
int x = in.nextInt();
del(x);
insert(x);
show(x);
}

}

}
```