Dieser Artikel teilt den entsprechenden Code für Java zur Implementierung von Listen mit einzelbremdeten Listen und mit zwei Wege verknüpften Listen für Ihre Referenz. Der spezifische Inhalt ist wie folgt
Java implementiert eine einzelne verknüpfte Liste:
Paketcode; Klasse Node {Knoten als nächstes; int Daten; public node (int data) {this.data = data; }} Klasse LinkList {Knoten zuerst; // Head public linkList () {this.first = null; } public void addnode (Knoten Nr.) {no.Next = First; first = no; // in den Kopf hinzufügen} public void DeLectnode () {Knoten n = first.Next; zuerst = null; first = n; // im Kopf löschen} // Die angegebene Position public int number () {int count = 1; // Sehen Sie, wie viele Elemente dort Node Nd = zuerst sind; while (nd.next! = null) {nd = nd.next; zählen ++; } return count; } public void DeLectExact (int n) {// Die angegebene Position löschen if (n> 1) {int count = 1; Knoten de = zuerst; while (count <n-1) {de = de.Next; zählen ++; } de.next = de.next.next; } else first = first.Next; } public void addexact (int n, node nd) {if (n> 1) // Hinzufügen der angegebenen Position {int count = 1; Knoten de = zuerst; while (count <n-1) {de = de.Next; zählen ++; } nd.next = de.Next; De.Next = nd; } else first = first.Next; } public int findNode (int n) {int count = 1; // Finden Sie die Position, die einem Zahlenknoten de = zuerst entspricht; while (de.data! = n) {de = de.Next; zählen ++; if (de == null) {return -1; }} return count; } public void print () {node no = zuerst; // drucken Sie alle (no! = null) {System.out.println (Nr. Data); NEIN = Nr. NEXT; }}} public class TextNode {public static void main (string [] args) {linkList ll = new linkList (); ll.addnode (neuer Knoten (12)); ll.addnode (neuer Knoten (15)); ll.addnode (neuer Knoten (18)); ll.addnode (neuer Knoten (19)); ll.addnode (neuer Knoten (20)); /* system.out.println(ll.first.data); ll.delectnode (); System.out.println (ll.first.data);*/ system.out.println (ll.number ()); ll.delectExact (3); ll.addexact (3, neuer Knoten (100)); System.out.println (ll.number ()); // ll.print (); System.out.println (ll.findnode (112)); }}Java implementiert eine verknüpfte Liste mit zwei Wegen:
public class doubelink {public static void main (String [] args) {node2 no = new node2 (5); Nr. Addleft (neuer Node2 (6)); Nr. Addright (neuer Node2 (7)); /*no.print (); Nr. print2 ();*/ no.Addexact2 (1, neuer Node2 (8)); Nr. print (); System.out.println ("-------------------"); Nr. print2 (); }} Klasse node2 {public node2 zuerst; öffentlicher Node2 Ende; öffentlicher Node2 übrig; öffentlicher Node2 Recht; int data = 0; public node2 (int n) {first = this; Ende = dies; zuerst.data = n; } // Fügen Sie public void aus dem Kopf addleft (node2 vor) {first.left = vor; vorher.Right = zuerst; zuerst = vor; } // Fügen Sie die öffentliche Leere aus dem Heck -AddRight hinzu (Node2 nach) {end.right = After; After.Left = Ende; Ende = Nachher; } // Einfügen die Anzahl der öffentlichen void addexact (int n, node2 no) {int count = 0; if (n == 0) {addleft (no); } else {node2 f = zuerst; while (true) {f = f.right; zählen ++; if (count == n) {// Dies ist die Änderung des Zeigens der vier Zeiger Nr. LEFT = F.LETT; f.left.right = no; // First.left = no; Nr. Right = f; f.left = no; brechen; }}}}} // Fügen Sie die Anzahl der öffentlichen void addExact2 (int n, node2 no) {int count = 0 ein; if (n == 0) {addright (no); } else {node2 f = end; while (true) {f = f.left; zählen ++; if (count == n) {no.Left = f; Nr. Right = F.Right; f.right.left = no; f.Right = nein; brechen; }}}}} // Positive Traversal public void print () {System.out.println (first.data); while (first.right! = null) {System.out.println (first.right.data); zuerst = zuerst.Right; } // system.out.println (end.data); } // Umgekehrter Reihenfolge von Traversal public void print2 () {System.out.println (end.data); while (end.left! = null) {System.out.println (end.left.data); End = Ende.Left; }}}/*Es ist erwähnenswert, dass Sie jedes Mal, wenn ein neues Objekt eingefügt wird, auf die Änderung des Zeigers achten müssen. Zunächst das Zeigen beider Seiten dieses neuen Objekts (links und rechts), gefolgt vom Zeigen des linken Objekts nach rechts und dem Zeigen des rechten Objekts nach links. Das Zeigen dieser vier Zeiger muss korrekt sein, sonst kann dies dazu führen, dass die Traversal positiv oder umgekehrter Reihenfolge implementiert wird. *//*Vergleichen Sie einzelne verknüpfte Listen, einzelne verknüpfte Listen können nur aus einer Richtung durchquert werden, da nur ein Kopf vorhanden ist, während eine bidirektionale verknüpfte Liste einen Kopf und einen Schwanz hat. Es kann vom * Kopf oder vom Schwanz durchquert werden. Da eines der Objekte Hinweise in zwei Richtungen hat, kann es das * Objekt links und das Objekt rechts erhalten. * Aber für einzelne Listen, da es nur eine Richtung gibt, können sie nur nach links oder rechts gehen. Beim Hinzufügen von Objekten können Sie sie auch vom Anfang oder vom Ende hinzufügen. * Wenn eine einzelne verlinkte Liste zwei Anweisungen hinzufügen muss, ist sie selten oder nicht, da sie nur nach links oder rechts Hinweise auf eine Richtung hat, während jedes Objekt einer bidirektionalen verlinkten Liste Zeiger auf zwei Richtungen hat, die nicht flexibler sind, aber dies hat auch mehr Erkenntnisse, da auch zwei Hinweise auf diese Weise enthalten sind. * * *//Das obige dreht sich alles um diesen Artikel. Ich hoffe, dass es für alle hilfreich sein wird, Java -Programme zu lernen.