Java implementiert die Funktion des Hinzufügens und Löschens von Zwei-Wege-verknüpften Listen

Java implementiert die Funktion des Hinzufügens und Löschens von Zwei-Wege-verknüpften Listen, vollständiger Code

 Paket verlinkt; Klasse LinkedTable {} öffentliche Klasse LinkedTabletest {// Konstruieren Sie eine einzelne verknüpfte Liste statischer Knoten node1 = neuer Knoten ("name1"); statischer Knoten node2 = neuer Knoten ("name2"); statischer Knoten node3 = neuer Knoten ("name3"); statischer Knoten node4 = neuer Knoten ("name4"); statischer Knoten node5 = neuer Knoten ("name5"); public static void main (String [] args) {// Zeiger Sollpoint () setzen; // Schleife durch System.out.println ("*************************"); out (node1, node5); System.out.println (); // Knoten hinter node2 addnode (node2, node3) einfügen; // Schleife durch System.out.println ("******* Einfügen Node2.5 *********"); out (node1, node5); System.out.println (); // Knoten node2.setNextNode (node3) löschen; node3.setNextNodef (node2); // Schleifen Sie durch System.out.println ("******* löschen Node2.5 *******"); out (node1, node5); System.out.println (); } // Zeiger public static void sadpoint () {// stürmen pointer node1.setNextNode (node2) einstellen; node2.setNextNode (node3); node3.setNextNode (node4); node4.setNextNode (node5); // Reverse Pointer Node5.setNextNodef (NODE4) festlegen; node4.setNextNodef (node3); node4.setNextNodef (node3); node3.setNextNodef (node2); node2.setNextNodef (node1); } // Schleifen Sie durch die einzelne verlinkte Liste öffentlich statische statische Void -überdachte (Knoten startnode) {node node = new node (); node.setNextNode (startNode); do {node = node.getNextNode (); System.out.print (node.getName ()+"----"); } while (node.getNextNode ()! = null); } // umgekehrt durch die einzelne verknüpfte Liste öffentliche statische statische Void Overtinkedf (Knotenendnode) {node node = new node (); node.setNextNodef (EndNode); do {node = node.getNextNodef (); System.out.print (node.getName ()+"----"); } while (node.getNextNodef ()! = null); } // Schleifen Sie durch public static void out (Knoten startnode, Knotenendnode) {überragend (startNode); System.out.println (); overtinkedf (EndNode); } // Knoten public static void addnode (Knoten -Prenode, Knoten NextNode) {Node node_add = new node ("name2.5"); node_add.setNextNode (prenode.getNextNode ()); PREENODE.SETNEXTNODE (NODE_ADD); node_add.setNextNodef (NextNode.getNextNodef ()); NextNode.setNextNodef (node_add); }} Klasse Node {privater String -Name; privater Knoten NextNode; privater Knoten NextNodef; public void setName (String name) {this.name = name; } public void setNextNode (Knoten NextNode) {this.NextNode = NextNode; } public void setNextNodef (Knoten NextNodef) {this.NextNodef = NextNodeF; } public String getName () {return this.name; } public node getNextNode () {return this.NextNode; } public node getNextNodef () {return this.NextNodeF; } public node (String name) {this.name = name; this.NextNode = null; } public node () {}}

1. Die Konstruktion eines Knotenknotens erfordert zwei Zeiger, um die Position des nächsten Elements zu speichern, und die andere für die Rückseite der Position des nächsten Elements.

Parameterbeschreibung:

Name: Wird verwendet, um die eigenen Informationen des Knotens zu speichern

NextNode: Wird verwendet, um Vorwärtszeiger zu speichern

NextNodef: Wird verwendet, um Reverse -Zeiger zu speichern

 Klasse Node {privater Zeichenfolge Name; privater Knoten NextNode; privater Knoten NextNodef; public void setName (String name) {this.name = name; } public void setNextNode (Knoten NextNode) {this.NextNode = NextNode; } public void setNextNodef (Knoten NextNodef) {this.NextNodef = NextNodeF; } public String getName () {return this.name; } public node getNextNode () {return this.NextNode; } public node getNextNodef () {return this.NextNodeF; } public node (String name) {this.name = name; this.NextNode = null; } public node () {}}

2. Erstellen Sie einen Knoten und stellen Sie einen Zeiger ein, um eine Verbindung zum Knoten herzustellen

Vorwärtszeiger: Zeigen Sie auf den nächsten Knoten

Rückwärtsknoten: Zeigen Sie auf den vorherigen Knoten

 // Erstellen Sie eine einzelne verknüpfte Liste statischer Knoten node1 = neuer Knoten ("name1"); statischer Knoten node2 = neuer Knoten ("name2"); statischer Knoten node3 = neuer Knoten ("name3"); statischer Knoten node4 = neuer Knoten ("name4"); statischer Knoten node5 = neuer Knoten ("name5");

 public static void sadpoint () {// Setzen Sie den Vorwärts -Zeiger node1.setNextNode (node2); node2.setNextNode (node3); node3.setNextNode (node4); node4.setNextNode (node5); // Setzen Sie den Reverse -Zeiger node5.setNextNodef (node4); node4.setNextNodef (node3); node3.setNextNodef (node2); node2.setNextNodef (node1); }

3.. Schleifen Sie die verknüpfte Liste über die Ausgabe ab

 public static void outrinked (Knoten startnode) {node node = new node (); node.setNextNode (startNode); do {node = node.getNextNode (); System.out.print (node.getName ()+"----"); } while (node.getNextNode ()! = null); }

 public static void outrinkedf (node endnode) {node node = new node (); node.setNextNodef (EndNode); do {node = node.getNextNodef (); System.out.print (node.getName ()+"----"); } while (node.getNextNodef ()! = null); }

4. Fügen Sie Knoten hinzu

 public static void addnode (Knoten -Prenode, Knoten NextNode) {Node node_add = new node ("name2.5"); node_add.setNextNode (prenode.getNextNode ()); PREENODE.SETNEXTNODE (NODE_ADD); node_add.setNextNodef (NextNode.getNextNodef ()); NextNode.setNextNodef (node_add); }

5. Knoten löschen

 node2.setNextNode (node3); node3.setNextNodef (node2);

Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.