La copie de code est la suivante: Liste des packages;
import java.util.arraylist;
/ **
* Problème Java Joseph: N individus (ID différents) forment un cercle, commencez à compter M (n'importe quel nombre) à partir de StartID (n'importe quel nombre).
* Ensuite, commencez à compter les numéros de la personne suivante, et le comptage de M sera radié à la fin de la nouvelle file d'attente.
* Imprimez la nouvelle file d'attente après avoir été supprimé
*
* Par exemple
* int n = 10; // nombre total de personnes
* int m = 3;
* int startIndex = 1;
* @Author Hulk 2014 03 20
*
* /
classe publique josephlisttest {
public static void main (String [] args) {
Long startTime = System.CurrentTimemillis ();
Josephlisttest test = new JosePhListTest ();
int n = 10; // nombre total de personnes
int m = 3; // signaler le nombre de nombres
int startIndex = 12;
System.out.println ("JosePhListtest: n =" + n + ", m =" + m +
", startIndex =" + startIndex + "/ n / nQueue Résultat:");
ArrayList <Songe> queuelist = test.QueepReson (N, M, startIndex);
pour (personne personne: queuelist) {
System.out.println ("Out Person:" + personne);
}
System.out.println ("Utiliser Time =" +
(System.CurrentTimemillis () - Starmtime));
}
Private ArrayList <Songe> QueuepReson (int n, int m, int startIndex) {
ArrayList <Ponon> QueuElist = null;
PersonList list = CreateList (n);
//list.search ();
if ((list! = null) && (list.head! = null)) {
queuelist = new ArrayList <JosePhListTest.Serson> ();
Pnode pnode = list.head;
if (startIndex> 0) {
startIndex = startIndex% n;
pnode = list.getNode (startIndex);
} autre {
pnode = list.head;
}
int count = 1;
while (list.size> 0) {
Personne Outperson = NULL;
//trouver
if (count == (m - 1)) {
// Supprimer le nœud suivant
Personne prev = pnode.person;
Outperson = list.remove (prev);
queuelist.add (Outperson);
//System.out.println("out Person: "+ Outperson +", size = "+ list.size);
count = 0;
}
pnode = pnode.next;
Count ++;
}
}
RETOUR QUEULIST;
}
Personlist CreateList (int n) {
PersonList list = new PersonList ();
pour (int i = 0; i <n; i ++) {
Personne personne = new personne (i, "name_" + (i + 1));
list.add (i, personne);
}
Liste de retour;
}
classe publique Personlist {
Pnode head = null;
int size = 0;
Public PersonList () {
}
liste de personnes publiques (personne personne) {
head = new pnode (personne, tête);
taille ++;
}
Public Personlist (Pnode Head) {
this.head = tête;
head.setNext (tête);
taille ++;
}
public pnode gethead () {
Tête de retour;
}
public void Sethead (Pnode Head) {
this.head = tête;
}
public int getSize () {
taille de retour;
}
public void setSize (int size) {
this.size = size;
}
Taille du public public (taille int) {
this.size = size;
}
public booléen iSempty () {
retourne this.size <= 0;
}
public void inithead (personne personne) {
if (size == 0) {
head = new pnode (personne, tête);
} autre {
Pnode no = tête;
head = new Pnode (personne, non);
}
taille ++;
}
public void add (int index, personne personne) {
if (size == 0) {
head = new pnode (personne, tête);
head.setNext (tête);
//System.out.println("head: "+ tête);
} autre {
if (index <0) {
index = 0;
}
if (index> size) {
index = taille;
}
Pnode no = tête;
pour (int i = 0; i <(index - 1); i ++) {
NON = NO.NEXT;
}
Pnode newNode = new pnode (personne, n ° NEXT);
n ° NEXT = newNode;
}
taille ++;
}
Public Delete (int index) {
Pnode pnode = re Support (index);
if ((pNode! = null) && (pnode.next! = null)) {
return pnode.next.person;
}
retourner null;
}
Public Pnode Suppor (int index) {
if (size == 0) {
retourner null;
} autre {
if ((index <0) || (index> = size)) {
retourner null;
}
}
Pnode no = tête;
pour (int i = 0; i <(index - 1); i ++) {
NON = NO.NEXT;
}
Non.
taille--;
if ((non! = null) && (n °Next! = null)) {
retour n ° NEXT;
}
retourner null;
}
/ **
* Retirez le nœud du nœud de la personne et renvoyez la personne supprimée
* @param preserson
* @return enlevé la personne
* /
Public enlever (personne Preperson) {
if (preserson == null) {
retourner null;
}
if (size == 0) {
retourner null;
}
Pnode prenode = tête;
int index = -1;
pour (int i = 0; i <size; i ++) {
if (prenode.person.id == preserson.id) {
index = i;
casser;
} autre {
Prenode = Prenode.Next;
}
}
Personne REMPERSON = NULL;
if (taille <= 1) {
// Un seul nœud, obtenez sa personne et définissez-la comme nul
remperson = prenode.person;
prenode = null;
} autre {
//prenode.next.person est dest One
remerSon = prenode.next.person;
prenode.next = prénode.next.next;
}
taille--;
//System.out.println("deleteing index = "+ index +": "+ rehperson +", size = "+ size);
retour REMPERSON;
}
Public Int Update (Person Src, Person Dest) {
if (src == null) {
retour -1;
}
int index = -1;
Pnode no = tête;
pour (int i = 0; i <size; i ++) {
if (src.id == n ° personne.id) {
Non. Person = dest;
casser;
} autre {
NON = NO.NEXT;
}
}
Index de retour;
}
ensemble booléen public (int index, personne personne) {
if (personne == null) {
retourne false;
}
if (size == 0) {
retourne false;
} autre {
if ((index <0) || (index> = size)) {
retourne false;
}
}
Pnode no = tête;
pour (int i = 0; i <index; i ++) {
NON = NO.NEXT;
}
Non. Personne = personne;
Retour Vrai;
}
le public obtient (int index) {
Pnode no = getNode (index);
if (non! = null) {
retour n ° personne;
}
retourner null;
}
public pnode getNode (int index) {
if (size == 0) {
retourner null;
} autre {
if ((index <0) || (index> = size)) {
retourner null;
}
}
Pnode no = tête;
pour (int i = 0; i <index; i ++) {
NON = NO.NEXT;
}
retour n °;
}
Public Void Search () {
int sizelong = taille;
Pnode no = tête;
pour (int i = 0; i <sizelong; i ++) {
System.out.println ("Search index =" + i + "," + no);
NON = NO.NEXT;
}
}
}
classe publique Pnode {
Personne personne;
PNODE NEXT = NULL;
public pnode () {
}
pnode public (personne personne) {
this.person = personne;
}
public pnode (personne personne, pnode suivant) {
this.person = personne;
this.next = suivant;
}
@Outrepasser
public String toString () {
return "pnode [personne =" + personne.id + ", next =" + next.epers.id +
"]";
}
Public Getperson () {
personne de retour;
}
public void Setperson (personne personne) {
this.person = personne;
}
public pnode getNext () {
retour ensuite;
}
public void setNext (pnode suivant) {
this.next = suivant;
}
}
classe publique Personne {
int id = 0;
String name = "";
Public () {
}
Public (int id, nom de chaîne) {
super();
this.id = id;
this.name = name;
}
@Outrepasser
public String toString () {
return "personne [id =" + id + ", name =" + name + "]";
}
}
}