La copia del código es la siguiente: Lista de paquetes;
import java.util.arrayList;
/**
* Problema de Java Joseph: N individuos (diferentes IDS) forman un círculo, comienzan a contar M (cualquier número) a partir de Startid (cualquier número).
* Luego, comience a contar M números de la siguiente persona, y contando M se eliminará al final de la nueva cola.
* Imprima la nueva cola después de ser retirada
*
* p.ej
* int n = 10; // número total de personas
* int m = 3;
* int startIndex = 1;
* @author Hulk 2014 03 20
*
*/
clase pública Josephlisttest {
public static void main (string [] args) {
Long Starttime = System.CurrentTimemillis ();
JosephlistTest test = new JosephListTest ();
int n = 10;
int m = 3;
int startIndex = 12;
System.out.println ("JosephListTest: N =" + N + ", M =" + M +
", startIndex =" + startIndex + "/n/nqueue resultado:");
ArrayList <Oller> queuelist = test.queuePreson (n, m, startIndex);
para (persona persona: queuelista) {
System.out.println ("Out Person:" + Person);
}
System.out.println ("Use Time =" +
(System.CurrentTimemillis () - Starttime));
}
Private ArrayList <Oller> QueuePreson (int n, int m, int intotindex) {
ArrayList <Oller> queuelist = null;
Personlist list = createList (n);
//list.search ();
if ((list! = null) && (list.head! = null)) {
Queuelist = new ArrayList <josephlisttest.person> ();
Pnode pnode = list.head;
if (startIndex> 0) {
startIndex = startIndex % n;
pnode = list.getNode (startIndex);
} demás {
pnode = list.head;
}
int count = 1;
while (list.size> 0) {
Outputer de la persona = nulo;
//encontrar
if (count == (m - 1)) {
// Eliminar el siguiente nodo
Persona anterior = pnode.person;
outperson = list.remove (anterior);
Queuelist.Add (Outperson);
//System.out.println("out persona: " + outperson +", size = " + list.size);
recuento = 0;
}
pnode = pnode.next;
contar ++;
}
}
regresar queuelista;
}
Lista de personas privadas createlist (int n) {
Personlist list = new PersonList ();
para (int i = 0; i <n; i ++) {
Persona persona = nueva persona (i, "name_" + (i + 1));
list.add (i, persona);
}
lista de devolución;
}
Lista de personas de clase pública {
Pnode head = null;
int tamaño = 0;
Public PersonList () {
}
Lista de personas públicas (persona persona) {
cabeza = nuevo pnode (persona, cabeza);
tamaño ++;
}
Public Personlist (PNode Head) {
this.head = cabeza;
head.setNext (cabeza);
tamaño ++;
}
public pnode gethead () {
cabeza de regreso;
}
public void sethead (cabeza de pnode) {
this.head = cabeza;
}
public int getsize () {
tamaño de retorno;
}
public void setSize (int tamaño) {
this.size = size;
}
Tamaño de vacío público (tamaño int) {
this.size = size;
}
Public boolean isEtimty () {
devolver esto.size <= 0;
}
público nulo inithead (persona persona) {
if (size == 0) {
cabeza = nuevo pnode (persona, cabeza);
} demás {
Pnode no = cabeza;
cabeza = nuevo pnode (persona, no);
}
tamaño ++;
}
public void add (int index, persona persona) {
if (size == 0) {
cabeza = nuevo pnode (persona, cabeza);
head.setNext (cabeza);
//System.out.println("head: " + cabeza);
} demás {
if (index <0) {
índice = 0;
}
if (index> size) {
índice = tamaño;
}
Pnode no = cabeza;
para (int i = 0; i <(índice - 1); i ++) {
No = No.Next;
}
Pnode newnode = new PNode (persona, No.Next);
No.Next = Newnode;
}
tamaño ++;
}
Persona pública Eliminar (INT índice) {
Pnode pnode = remove (índice);
if ((pnode! = null) && (pnode.next! = null)) {
return pnode.next.person;
}
regresar nulo;
}
public pnode remove (int index) {
if (size == 0) {
regresar nulo;
} demás {
if ((index <0) || (index> = size)) {
regresar nulo;
}
}
Pnode no = cabeza;
para (int i = 0; i <(índice - 1); i ++) {
No = No.Next;
}
No.Next = No.Next.Next;
tamaño--;
if ((no! = null) && (no.next! = null)) {
regreso No.Next;
}
regresar nulo;
}
/**
* Eliminar el siguiente nodo del nodo de persona y devolver a la persona eliminada
* @param preferson
* @return eliminó persona
*/
Persona pública eliminar (persona preferson) {
if (preferson == null) {
regresar nulo;
}
if (size == 0) {
regresar nulo;
}
Pnode prenode = head;
int index = -1;
para (int i = 0; i <size; i ++) {
if (prenode.person.id == sugererson.id) {
índice = i;
romper;
} demás {
prenode = prenode.next;
}
}
Persona REMPERSON = NULL;
if (tamaño <= 1) {
// Solo un nodo, obtén a su persona y establece como nulo
REMPERSON = PRENODE.PERSON;
prenode = nulo;
} demás {
//prenode.next.person es des
REMPERSON = prenode.next.person;
prenode.next = prenode.next.next;
}
tamaño--;
//System.out.println("deleteing index = " + index +": " + rEMPERSON +", size = " + size);
Return Reperson;
}
Public int Update (Person Src, Person Dest) {
if (src == null) {
regreso -1;
}
int index = -1;
Pnode no = cabeza;
para (int i = 0; i <size; i ++) {
if (src.id == No.person.id) {
No.Poner = Dest;
romper;
} demás {
No = No.Next;
}
}
Índice de retorno;
}
set de booleano público (int index, persona persona) {
if (persona == nulo) {
devolver falso;
}
if (size == 0) {
devolver falso;
} demás {
if ((index <0) || (index> = size)) {
devolver falso;
}
}
Pnode no = cabeza;
para (int i = 0; i <index; i ++) {
No = No.Next;
}
No.Poner = persona;
devolver verdadero;
}
Public Person Get (int index) {
Pnode no = getNode (índice);
if (no! = null) {
RETURIDO No.Poneral;
}
regresar nulo;
}
public pnode getNode (int index) {
if (size == 0) {
regresar nulo;
} demás {
if ((index <0) || (index> = size)) {
regresar nulo;
}
}
Pnode no = cabeza;
para (int i = 0; i <index; i ++) {
No = No.Next;
}
regreso no;
}
Public void Search () {
int sizelong = tamaño;
Pnode no = cabeza;
para (int i = 0; i <sizelong; i ++) {
System.out.println ("Search index =" + i + "," + no);
No = No.Next;
}
}
}
clase pública Pnode {
Persona persona;
Pnode next = null;
public pnode () {
}
público pnode (persona persona) {
this.person = persona;
}
público pnode (persona persona, pnode siguiente) {
this.person = persona;
this.next = siguiente;
}
@Anular
public String toString () {
return "pnode [persona =" + persona.id + ", next =" + next.person.id +
"]";
}
Persona pública getperson () {
persona de regreso;
}
Public void setperson (persona persona) {
this.person = persona;
}
public pnode getNext () {
regresar a continuación;
}
public void setNext (pnode next) {
this.next = siguiente;
}
}
persona de clase pública {
int id = 0;
Name de cadena = "";
persona pública () {
}
Persona pública (int id, nombre de cadena) {
súper();
this.id = id;
this.name = name;
}
@Anular
public String toString () {
return "persona [id =" + id + ", nombre =" + nombre + "]";
}
}
}