Fonctionnement de la liste liée à Java: Liste des liens circulaires
Exemples d'analyse principale:
1. Liste récurrente liée unique
2. Liste récurrente à double liaison
Parmi eux, le nœud de liste unique et la classe de nœuds de liste à double liaison et l'interface iComoperate <T> sont cohérents avec l'article précédent et ne seront pas discutés ici. Référence: Liste liée à Java Opérations: liste unique et liste à double liaison //www.vevb.com/article/95113.htm
1. Liste récurrente liée unique
package linkListtest; import java.util.hashmap; import java.util.map; public class singlecycleLinkList implémente icomperate <node> {private snode head = new snode ("head"); // Pointeur d'en-tête public, inchangé après déclaration private int size = 0; public int getSize () {return this.Size; } / * * Insérez la liste liée, chaque fois qu'il est inséré à la fin, la norme pour déterminer si la fin pointe ensuite vers la tête * * / @Override public boolean insertnode (snode node) {booléen flag = false; initLinkList (); // Initialisez la liste liée if (this.size == 0) {// Liste liée vide this.head.setNextNode (node); node.setNextNode (this.head); } else {snode current = this.head; while (current.getNextNode ()! = this.head) {// Recherchez le nœud final current = current.getNextNode (); } current.setNextNode (node); node.setNextNode (this.head); // Suivez la mauvaise liste liée, le nœud de queue pointe vers la tête} this.size ++; Flag = true; drapeau de retour; } / * * Insérez la position spécifiée de la liste liée, à partir de 1, et POS est supérieur à la taille, l'insérez-la à la fin de la liste liée * * / @Override public boolean insertPosnode (int pos, snode node) {boolean flag = true; Snode current = this.head.getNextNode (); initLinkList (); // Initialise la liste liée if (this.size == 0) {// La liste liée est vide this.head.setNextNode (node); node.setNextNode (this.head); // Suivez la mauvaise liste liée, le nœud de queue pointe pour diriger ce.size ++; } else if (this.size <pos) {// La position POS est supérieure à la longueur de la liste liée, insérez l'insertnode final (nœud); } else if (pos> 0 && pos <= this.size) {// Le nœud dans la liste liée // 1. Trouvez le nœud et le nœud précédent à insérer, et le nœud sera inséré entre les deux nœuds int fin = 0; Snode prenode = this.head; // le nœud avant snode currentNode = current; // le nœud actuel while (trouver <pos-1 && currentNode! = This.head) {prenode = current; // Le nœud avant se déplace vers l'arrière currentNode = currentNode.getNextNode (); // Le nœud actuel est déplacé vers l'arrière Find ++; if (find <pos-1 && currentNode! = this.head) {// Le nœud n'est pas fini à la recherche du nœud, et le nœud est déplacé en arrière Current = current.GetNextNode (); }} // system.out.println (prenode); // system.out.println (currentNode); // 2. INSERT NODE PENODE.SETNEXTNODE (NODE); node.setNextNode (currentNode); this.size ++; } else {System.out.println ("Erreur d'information de position"); Flag = false; } drapeau de retour; } private void initLinkList () {if (size == 0) {this.head.setNextNode (this.head); }} / * * Spécifiez le nœud POS de la liste liée et supprimez le nœud correspondant. Méthode: Trouvez les nœuds avant et arrière à supprimer, supprimer et l'indice commence à partir de 1 * * / @Override public booolean Deletenode (int pos) {booléen flag = false; Snode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Erreur d'information de position ou aucune information dans la liste liée"); } else {// 1. Trouvez les nœuds avant et arrière pour supprimer int fin = 0; Snode prenode = this.head; // nœud avant snode nextNode = current.getNextNode (); // le nœud arrière while (find <pos-1 && nextNode! = This.head) {prenode = current; // Le nœud avant est déplacé en arrière nextNode = nextNode.getNextNode (); // Le nœud arrière est retiré en arrière Find ++; if (find <pos-1 && nextNode! = this.head) {// Le nœud avant n'est pas terminé, le "nœud avant" arrière est déplacé Current = current.GetNextNode (); }} // system.out.println (prenode); // system.out.println (nextNode); // 2. Supprimer le nœud prenode.setNextNode (nextNode); System.gc (); // recycler et supprimer le nœud this.size--; Flag = true; } drapeau de retour; } / * * Spécifiez le nœud POS de la liste liée, modifiez le nœud correspondant et l'indice commence à partir de 1 * * / @Override public booléen updatenode (int pos, map <string, object> map) {booléen flag = false; SNODE NODE = GETNODE (POS, MAP); // Obtenez le nœud à la pos correspondante if (nœud! = Null) {String data = (string) map.get ("data"); Node.setData (données); Flag = true; } drapeau de retour; } / * * Trouvez le nœud pos de la liste liée spécifiée, et l'indice commence à partir de 1 * * / @Override public snode getNode (int pos, map <string, object> map) {snode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Les informations de position sont incorrectes ou la liste liée n'existe pas"); retourner null; } int find = 0; while (find <pos-1 && current! = this.head) {current = current.getNextNode (); trouver ++; } Retour courant; } / * * Imprimer la liste liée * * / @Override public void printLink () {int length = this.size; if (longueur == 0) {System.out.println ("La liste liée est vide!"); retour ; } Snode courant = this.head.getNextNode (); System.out.println ("Nombre total de nœuds:" + longueur + "Ones"); int find = 0; while (current! = this.head) {System.out.println ("th" + (++ find) + "nœuds:" + courant); current = current.getNextNode (); }} public static void main (string [] args) {singlecycleLinkList scll = new singlecycleLinkList (); Snode node1 = new snode ("node1"); SNODE NODE2 = NOUVEAU SNODE ("NODE2"); SNODE NODE3 = NOUVEAU SNODE ("NODE3"); SNODE NODE4 = NOUVEAU SNODE ("NODE4"); SNODE NODE5 = NOUVEAU SNODE ("NODE5"); SNODE NODE6 = NOUVEAU SNODE ("INSERT Position spécifiée"); // Scll.InsertPosnode (scll.getSize () + 1, Node1); // Scll.InsertPosnode (scll.getSize () + 1, Node2); // Scll.InsertPosnode (scll.getsize () + 1, node2); // scll.insertPosnode (scll.getSize () + 1, node3); // scll.insertposnode (scll.getSize () + 1, node4); // scll.insertposnode (scll.getSize () + 1, node5); scll.insertNode (Node1); scll.insertNode (Node2); scll.insertNode (node3); scll.insertNode (Node4); scll.insertNode (Node5); System.out.println ("***********************************"); scll.printLink (); System.out.println ("************************** Obtenez le nœud de liste lié spécifié ***************************************"); int pos = 2; System.out.println ("Obtenez les données de position" + pos + "de la liste liée:" + scll.getNode (pos, null)); System.out.println ("***********************************"); int pos1 = 3; System.out.println ("insérer des données dans les nœuds" + pos1 + ":"); Scll.InsertPosnode (POS1, Node6); scll.printLink (); System.out.println ("***************************** Supprimer le nœud spécifié dans la liste liée ********************************"); int pos2 = 3; System.out.println ("Delete" + POS2 + "NODES:"); scll.deletetenode (pos2); scll.printLink (); System.out.println ("*********************************** Modifiez les nœuds d'emplacement spécifiés de la liste liée ***********************************"); int pos3 = 3; System.out.println ("Modifier" + Pos3 + "nœuds:"); Map <string, object> map = new Hashmap <> (); map.put ("data", "Ceci est un test"); scll.updatenode (pos3, map); scll.printLink (); }}2. Liste récurrente à double liaison
package linkListtest; import java.util.hashmap; import java.util.map; classe publique DoubleCycleLinkList implémente icomperate <dnode> {private dnode head = new dNode ("head"); // Pointeur d'en-tête public, inchangé après déclaration private int size = 0; // Enregistrez le nombre de nœuds de Liste lié public int getSize () {return this.size; } / * * Insérez la liste liée, chaque fois qu'il est inséré à la fin, la norme pour déterminer si la fin pointe ensuite vers la tête * * / @Override public boolean insertnode (dnode node) {boolean flag = false; initLinkList (); // Initialisez la liste liée dnode courant = this.head; if (this.size == 0) {// la liste liée vide this.head.setNextNode (node); node.setpriornode (this.head); node.setNextNode (this.head); } else {// Le nœud dans la liste liée while (current.getNextNode ()! = this.head) {// Recherchez le nœud final current = current.getNextNode (); } current.setNextNode (node); Node.setPriorNode (courant); node.setNextNode (this.head); // Redirigez la mauvaise liste liée, le nœud de queue pointe vers la tête} this.size ++; Flag = true; drapeau de retour; } / * * Insérez la position spécifiée de la liste liée, à partir de 1, et POS est supérieur à la taille, insérez la fin de la liste liée * * / @Override public booléen insertPosnode (int pos, dnode node) {boolean flag = true; initLinkList (); // Initialisez la liste liée dnode actuellement = this.head.getNextNode (); if (this.size == 0) {// La liste liée est vide this.head.setNextNode (node); node.setpriornode (this.head); node.setNextNode (this.head); this.size ++; } else if (pos> this.size) {// La position POS est supérieure à la longueur de la liste liée, insérez l'insertnode final (nœud); } else if (pos> 0 && pos <= this.Size) {// Le nœud dans la liste liée // 1. Trouvez le nœud POS à insérer, insérez la position de courant du nœud POS int fin = 0; while (find <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); trouver ++; } // 2. Insérer le nœud if (current.getNextNode () == this.head) {// nœud tail node.setpriornode (courant); node.setNextNode (this.head); current.setNextNode (nœud); } else if (current.getNextNode ()! = this.head) {// nœud intermédiaire node.setpriornode (current.getPriornode ()); node.setNextNode (courant); current.getPriorNode (). setNextNode (node); current.setPriornode (nœud); } this.size ++; } else {System.out.println ("Erreur d'information de position"); Flag = false; } drapeau de retour; } private void initLinkList () {if (size == 0) {this.head.setNextNode (this.head); this.head.setpriornode (this.head); }} / * * Spécifiez le nœud POS de la liste liée et supprimez le nœud correspondant. Méthode: Trouvez la suppression du nœud avant et arrière du nœud à supprimer, et l'indice commence à partir de 1 * * / @Override public boolean Deletenode (int pos) {booléen flag = false; Dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Les informations de position sont incorrectes ou la liste liée n'existe pas"); } else {// 1. Recherchez le nœud POS de l'emplacement à supprimer int fin = 0; while (find <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); trouver ++; } // 2. Delete nœud if (current.getNextNode () == this.head) {// nœud tail current.getPriorNode (). SetNextNode (this.head); } else if (current.getNextNode ()! = this.head) {// nœud intermédiaire courant.getPriorNode (). setNextNode (current.getNextNode ()); current.getNextNode (). setPriorNode (current.getPriorNode ()); } System.gc (); // Recycler et supprimer les nœuds this.size--; Flag = true; } drapeau de retour; } / * * Spécifiez le nœud POS de la liste liée, modifiez le nœud correspondant et l'indice commence à partir de 1 * * / @Override public booléen updatenode (int pos, map <string, object> map) {booléen flag = false; Dnode node = getNode (pos, map); if (node! = null) {String data = (string) map.get ("data"); Node.setData (données); Flag = true; } drapeau de retour; } / * * Trouvez le nœud pos de la liste liée spécifiée, et l'indice commence à partir de 1 * * / @Override public dnode getNode (int pos, map <string, object> map) {dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Les informations de position sont incorrectes ou la liste liée n'existe pas"); retourner null; } int find = 0; while (find <pos-1 && current! = this.head) {current = current.getNextNode (); trouver ++; } Retour courant; } / * * Imprimer la liste liée * * / @Override public void printLink () {int length = this.size; if (longueur == 0) {System.out.println ("La liste liée est vide!"); retour ; } Dnode current = this.head.getNextNode (); int find = 0; System.out.println ("Nombre total de nœuds:" + longueur + "Ones"); while (current! = this.head) {System.out.println ("th" + (++ find) + "one nœuds:" + courant); current = current.getNextNode (); }} public static void main (String [] args) {DoubleCycleLinkList dcll = new DoubleCycleLinkList (); Dnode node1 = new dnode ("node1"); Dnode node2 = new dnode ("node2"); Dnode node3 = new dnode ("node3"); Dnode node4 = new dnode ("node4"); Dnode node5 = new dnode ("node5"); Dnode node6 = new dnode ("insérer la position spécifiée"); dcll.InsertPosnode (10, Node1); dcll.insertPosnode (10, node2); dcll.insertPosnode (8, node3); dcll.insertPosnode (88, node4); dcll.insertPosnode (8, node5); // dcll.insertnode (node1); // dcll.insertnode (node2); // dcll.insertnode (node3); // dcll.insertnode (node4); // dcll.insertnode (node5); System.out.println ("****************************** ENTREPORT Liste liée *********************************"); dcll.printLink (); System.out.println ("**************************************"); int pos = 2; System.out.println ("Obtenez les données de position" + pos + "de la liste liée:" + dcll.getNode (pos, null)); System.out.println ("******************************** Insérez le nœud dans la position spécifiée de la liste liée ********************************"); int pos1 = dcll.getSize () + 1; System.out.println ("insérer les données dans" + Pos1 + "NODES:"); dcll.InsertPosnode (POS1, Node6); dcll.printLink (); System.out.println ("************************** Supprimer l'emplacement spécifié du nœud de la liste liée **********************************"); int pos2 = 7; System.out.println ("Delete" + POS2 + "NODES:"); dcll.deletetenode (pos2); dcll.printLink (); System.out.println ("*****************************************"); int pos3 = 3; System.out.println ("Modifier les nœuds" + pos3 + ":"); Map <string, object> map = new Hashmap <> (); map.put ("data", "Ceci est un test"); dcll.updatenode (pos3, map); dcll.printLink (); }}Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!