Java verknüpfte Listenbetrieb: Rundschreiben Linkliste
Beispiele für Hauptanalysen:
1. Einzelverlinkte List Recurrent List
2. Doppelverbundene Liste rezidivierende Liste
Unter ihnen stimmen die einköpfigen Listenknoten und die doppelt gebundene Listenknotenklasse und die Schnittstelle iCommoperate <T> mit dem vorherigen Artikel überein und werden hier nicht erörtert. Referenz: Java Linked List Operations: Single-Linked List und Double-Linked List //www.vevb.com/article/95113.htm
1. Einzelverlinkte List Recurrent List
Paket linkListTest; importieren java.util.hashMap; import java.util.map; öffentliche Klasse SinglecyclelinkList implementiert icommoperate <node> {private snode head = new Snode ("head"); // Public Header Zeiger, unverändert nach Deklaration private int size = 0; public int getSize () {return this.size; } / * * Fügen Sie die verknüpfte Liste ein, jedes Mal, wenn sie bis zum Ende eingefügt wird, der Standard zum Bestimmen des Endes zeigt auf den Kopf * * / @Override public boolean InsertNode (Snode -Knoten) {boolean flag = false; initlinkList (); // Initialisieren Sie die verknüpfte Liste if (this.size == 0) {// leere verlinkte Liste this.head.setNextNode (Knoten); node.setNextNode (this.head); } else {snode current = this.head; while (current.getNextNode ()! } current.setNextNode (Knoten); node.setNextNode (this.head); // Folgen Sie der schlechten verknüpften Liste, der Heckknoten zeigt auf den Kopf} this.size ++; Flag = wahr; Rückflagge; } / * * Fügen Sie die angegebene Position der verknüpften Liste ab 1 und POS größer als die Größe ein. Fügen Sie sie am Ende der verknüpften Liste ein. Snode current = this.head.getNextNode (); initlinkList (); // die verknüpfte Liste initialisieren if (this.size == 0) {// Die verknüpfte Liste ist leer. node.setNextNode (this.head); // Folgen Sie der schlechten verlinkten Liste, der Tail -Knoten verweist auf den Kopf. } else if (this.size <pos) {// Die POS -Position ist größer als die Länge der verknüpften Liste. Fügen Sie den Endnode (Knoten) ein; } else if (pos> 0 && pos <= this.size) {// Der Knoten in der verknüpften Liste // 1. Suchen Sie den Knoten und den vorherigen Knoten, der eingefügt werden soll, und der Knoten wird zwischen den beiden Knoten int in Find = 0 eingefügt; Snode prenode = this.head; // der vordere Knoten Snode currentNode = Strom; // Der aktuelle Knoten while (finde <pos-1 && currentNode! = This.head) {prenode = current; // Der vordere Knoten bewegt rückwärts currentNode = currentNode.getNextNode (); // Der aktuelle Knoten wird rückwärts find ++ bewegt; if (find <pos-1 && currentNode! }} // system.out.println (prenode); // system.out.println (currentNode); // 2.. node.setNextNode (currentNode); this.size ++; } else {System.out.println ("Positionsinformationsfehler"); Flag = Falsch; } Rückkehrflag; } private void initlinkList () {if (size == 0) {this.head.setNextNode (this.head); }} / * * Geben Sie den Knoten POS der verknüpften Liste an und löschen Sie den entsprechenden Knoten. Methode: Suchen Sie die Vorder- und Rückknoten zum Löschen, Löschen und das Index startet von 1 * */ @Override public boolean deleteNode (int pos) {boolean flag = false; Snode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Positionsinformationsfehler oder keine Informationen in der verknüpften Liste"); } else {// 1. Finden Sie die vorderen und hinteren Knoten, um int find = 0 zu löschen; Snode prenode = this.head; // Frontknoten snode snode neutnode = cururrow.getNextNode (); // Der Backknoten while (finde <pos-1 && nextNode! = This.head) {prenode = current; // Der vordere Knoten wird zurückgezogen von nächstenNode = NextNode.getNextNode (); // Der Backknoten wird zurückgezogen Find ++; if (find <pos-1 && nextNode! }} // system.out.println (prenode); // system.out.println (NextNode); // 2. Löschen Sie den Knoten prenode.setNextNode (NextNode); System.gc (); // recyceln und löschen Sie den Knoten this.size--; Flag = wahr; } Rückkehrflag; } / * * Geben Sie den Knoten POS der verknüpften Liste an, ändern Sie den entsprechenden Knoten und das Index startet mit 1 * * / @Override public boolean updateNode (int pos, map <String, Objekt> Karte) {boolean flag = false; Snode node = getNode (pos, map); // den Knoten am entsprechenden pos if (node! = Null) {string data = (string) map.get ("data"); node.setData (Daten); Flag = wahr; } Rückkehrflag; } / * * Finden Sie den Knoten -POS der angegebenen verknüpften Liste, und das Index startet mit 1 * * / @Override public snode getNode (int pos, map <string, Objekt> map) {snode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Positionsinformationen sind falsch oder die verlinkte Liste existiert nicht"); null zurückkehren; } int find = 0; while (finde <pos-1 && current! = this.head) {current = current.getNextNode (); Finden Sie ++; } Return Current; } / * * Verlinkte Liste drucken * * * / @Override public void printlink () {int länge = this.size; if (Länge == 0) {System.out.println ("Die verlinkte Liste ist leer!"); zurückkehren ; } Snode current = this.head.getNextNode (); System.out.println ("Gesamtzahl der Knoten:" + Länge + ""); int find = 0; while (current! current = current.getNextNode (); }} public static void main (String [] args) {SinglecyclelinkList scll = new SinglecyclelinkList (); Snode node1 = new snode ("node1"); Snode node2 = new snode ("node2"); Snode node3 = new snode ("node3"); Snode node4 = new snode ("node4"); Snode node5 = new snode ("node5"); SNode node6 = new SNode("Insert specified position");// 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("************************ Get the specified linked list node*************************************"); int pos = 2; System.out.println ("Get die Position" Position+"der verknüpften Liste der verknüpften Liste:"+scll.getNode (pos, null)); System.out.println("*********************************"); int pos1 = 3; System.out.println ("Daten in die"+pos1+"-Knoten einfügen:"); scll.insertposnode (pos1, node6); scll.printlink (); System.out.println ("****************************************************************************************************************************************************************************************************************************************************************); int pos2 = 3; System.out.println ("löschen"+pos2+"Knoten:"); scll.deletEnode (pos2); scll.printlink (); System.out.println ("******************************************************************************************************************** int pos3 = 3; System.out.println ("modify"+pos3+"Knoten:"); Karte <String, Objekt> map = new HashMap <> (); map.put ("Daten", "Dies ist ein Test"); scll.updatenode (pos3, map); scll.printlink (); }}2. Doppelverbundene Liste rezidivierende Liste
Paket linkListTest; import java.util.hashMap; import java.util.map; public class doublecyclelinklist implementiert icommoperate <dnode> {private dnode head = new Dnode ("head"); // Public Header Zeiger, unverändert nach Deklaration private int size = 0; // Aufzeichnen Sie die Anzahl der Knoten der verknüpften Liste öffentlich int GetSize () {return this.size; } / * * Fügen Sie die verknüpfte Liste ein, jedes Mal, wenn sie bis zum Ende eingefügt wird, ist der Standard zum Bestimmen, ob das Ende als nächstes auf den Kopf zeigt initlinkList (); // Initialisieren Sie die verknüpfte Liste dnode current = this.head; if (this.size == 0) {// Die leere verlinkte Liste This.head.SetNextNode (Knoten); node.setPriornode (this.head); node.setNextNode (this.head); } else {// Der Knoten in der verknüpften Liste (current.getNextNode ()! } current.setNextNode (Knoten); node.setPriornode (Strom); node.setNextNode (this.head); // Die schlechte verlinkte Liste umleiten, der Heckknoten zeigt auf den Kopf} this.size ++; Flag = wahr; Rückflagge; } / * * Fügen Sie die angegebene Position der verknüpften Liste ab 1 ein und POS ist größer als die Größe. Fügen Sie das Ende der verknüpften Liste ein. initlinkList (); // Initialisieren Sie die verknüpfte Liste dnode aktuell = this.head.getNextNode (); if (this.size == 0) {// Die verknüpfte Liste ist leer this.head.setNextNode (Knoten); node.setPriornode (this.head); node.setNextNode (this.head); this.size ++; } else if (pos> this.size) {// Die POS -Position ist größer als die Länge der verknüpften Liste, fügen Sie den Endnode (Knoten) ein; } else if (pos> 0 && pos <= this.size) {// Der Knoten in der verknüpften Liste // 1. Finden Sie den zugefügten POS -Knoten, fügen Sie die POS -Knoten aktuelle Position in int find = 0 ein; while (find <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); Finden Sie ++; } // 2. Node if (current.getNextNode () == this.head) {// Tail Node node.setPriornode (current); node.setNextNode (this.head); Current.SetNextNode (Knoten); } else if (current.getNextNode ()! node.setNextNode (aktuell); current.getPriornode (). setNextNode (Knoten); current.setPriornode (Knoten); } this.size ++; } else {System.out.println ("Positionsinformationsfehler"); Flag = Falsch; } Rückkehrflag; } private void initlinkList () {if (size == 0) {this.head.setNextNode (this.head); this.head.setPriornode (this.head); }} / * * Geben Sie den Knoten POS der verknüpften Liste an und löschen Sie den entsprechenden Knoten. Methode: Finden Sie die vordere und hintere Knoten -Löschung des zu löschenden Knotens, und das Index startet mit 1 * */ @Override public boolean deleteNode (int pos) {boolean flag = false; Dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Positionsinformationen sind falsch oder die verlinkte Liste existiert nicht"); } else {// 1. Finden Sie den Ort -POS -Knoten, der gelöscht werden soll. Int find = 0; while (find <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); Finden Sie ++; } // 2. Knoten löschen if (current.getNextNode () == this.head) {// Tail -Knoten current.getPriornode (). SetNextNode (this.head); } else if (current.getNextNode ()! current.getNextNode (). setPriornode (current.getPriornode ()); } System.gc (); // Knoten recyceln und löschen. Flag = wahr; } Rückkehrflag; } / * * Geben Sie den Knoten POS der verknüpften Liste an, ändern Sie den entsprechenden Knoten und das Index startet mit 1 * * / @Override public boolean updateNode (int pos, map <String, Objekt> Karte) {boolean flag = false; Dnode node = getNode (pos, map); if (node! = null) {string data = (string) map.get ("data"); node.setData (Daten); Flag = wahr; } Rückkehrflag; } / * * Suchen Sie den Knoten -POS der angegebenen verlinkten Liste, und das Index startet mit 1 * * / @Override public dnode getNode (int pos, map <string, Objekt> map) {dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Positionsinformationen sind falsch oder die verlinkte Liste existiert nicht"); null zurückkehren; } int find = 0; while (finde <pos-1 && current! = this.head) {current = current.getNextNode (); Finden Sie ++; } Return Current; } / * * Verlinkte Liste drucken * * * / @Override public void printlink () {int länge = this.size; if (Länge == 0) {System.out.println ("Die verlinkte Liste ist leer!"); zurückkehren ; } Dnode current = this.head.getNextNode (); int find = 0; System.out.println ("Gesamtzahl der Knoten:" + Länge + ""); while (current! 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 = neuer dnode ("angegebene Position einfügen"); 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("****************************** Output linked list*******************************"); dcll.printlink (); System.out.println("************************************"); int pos = 2; System.out.println ("Get die Position" Position+"der verknüpften Liste der verknüpften Liste:"+dcll.getNode (pos, null)); System.out.println ("************************************************************************************************************************************************************************. int pos1 = dcll.getSize ()+1; System.out.println ("Daten in"+pos1+"Knoten:"); dcll.insertposnode (pos1, node6); dcll.printlink (); System.out.println ("****************************************************************************************************************************************************************************************************************************************************************************************); int pos2 = 7; System.out.println ("löschen"+pos2+"Knoten:"); dcll.deletEnode (pos2); dcll.printlink (); System.out.println ("**************************************************************************** int pos3 = 3; System.out.println ("Ändern Sie"+pos3+"Knoten:"); Karte <String, Objekt> map = new HashMap <> (); map.put ("Daten", "Dies ist ein Test"); dcll.updatenode (pos3, map); dcll.printlink (); }}Danke fürs Lesen, ich hoffe, es kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!