## Single linked list

Little prince single linked list

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:

1. Create initial linked list

2. Delete linked list

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 Node head = new Node(1);//Head node //Initialize linked list static void init() { Node x = head; 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; } } //Insert element (header) static void insert(int x) { Node temp = new Node(x); temp.next = head.next; head.next = temp; } //Display linked list 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); } } }

## Circular linked list

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.

That is, x.next = head.

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 Node x = head; //Initialize circular linked list for(int i = 2; i <= N; i++) { x = (x.next = new Node(i)); x.next = head;//Form a circular linked list }//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); } }

## Bidirectional linked list

Little prince double linked list

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 Node head = new Node(1);//Head node //Initialize linked list static void init() { Node x = head; 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 } } } //Insert node (head insert) static void insert(int x) { Node temp = new Node(x); temp.next = head.next; temp.next.befor = temp; head.next = 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 } //Display linked list 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); } } }