Vorwort
Eine verknüpfte Liste ist eine gemeinsame grundlegende Datenstruktur. Es ist eine lineare Tabelle, wird aber nicht nacheinander im Speicher gespeichert. Es wird in Kettenform gespeichert. Jeder Knoten speichert den "Zeiger" des nächsten Knotens. Daten in Java sind in Referenzdatentypen und grundlegende Datentypen unterteilt. Es gibt kein Konzept von Zeigern in Java, aber für verknüpfte Listen beziehen sich Zeiger auf die Adresse von Referenzdatentypen.
Verbindete Listen und Arrays sind beide lineare Datenstrukturen und ihre Länge ist für Arrays festgelegt. Da sie im Gedächtnis kontinuierlich sind, eignen sie sich besser für die Suche und den Durchqueren. Verbindete Listen werden nicht nacheinander im Speicher gespeichert, sondern weil sie aus "Zeigern" bestehen, ist es bequemer, Arrays beim Einfügen und Löschen zu vergleichen.
Der folgende Code implementiert eine einfache Datenstruktur einer in Java -Sprache in Java -Sprache beschriebenen Datenstruktur und rekursive Methoden. Schauen wir uns die detaillierte Einführung an.
Definition der verknüpften Listendatenstruktur
Schauen wir uns zunächst die Definition der verknüpften Listendatenstruktur an. Der Code lautet wie folgt:
Klasse nodeManager {private Knoten root; // Root -Knoten private int currentIndex = 0; // Knoten -Seriennummer, jede Operation beginnt mit 0 public void add (int data) {} public void delnode (int data) {} public void print () {} public boolean findNode (int data) {} public boolean updateNode (int oldata, int NewData). Klassenknoten {private int Data; Privatknoten als nächstes; // Nehmen Sie den aktuellen Typ als öffentliche Node (int data) {this.data = data; } public void setData (int data) {this.data = data; } public int getData () {returndaten; } // Knoten public void addnode (int data) {} // Knoten public void delnode (int data) {} // Alle Knoten public void printNode () {} // Finden Sie den Knoten aus, der public boolean findnode (inta) {} // ändern node public boolan updatenode (int olde olda, intal) {/ // node public boolan updatenode extrains usan updatenode extrains upistataNode, (int olda, inta {/ Knoten public void InsertNode (int Index, int data) {}}}Für die Definition verknüpfter Listen wird die NodeManager -Klasse zum Verwalten verknüpfter Listenvorgänge verwendet, während der interne Klassenknoten der Mitgliedsklasse verwendet wird, um verknüpfte Listendaten und Kettenstruktur bereitzustellen. Für die Klassenbenutzer werden auf Daten nicht direkt zugegriffen, sodass die NodeManager -Klasse arbeitet, und der interne Klassenknoten bietet ein echtes Datenmanagement. Daher muss die Knotenklasse echte Datenbetriebmethoden bereitstellen, und die NodeManager -Klasse muss auch eine Reihe von Methoden bereitstellen, um verknüpfte Listen nach extern zu betreiben. Daher bieten sowohl die Nodemanager -Klasse als auch die Knotenklasse scheinbar die gleichen Methoden, aber die tatsächliche Bedeutung ist nicht gleich.
Überprüfen Sie die Methode add () in der NodeManager -Klasse und in der Knotenklasse. Der Code ist wie folgt:
public void add (int data) {if (root == null) {root = neuer Knoten (Daten); } else {root.addnode (Daten); }} // Knoten public void addnode (int data) {if (this.Next == null) {this.Next = neuer Knoten (Daten); } else {this.next.addnode (Daten); }}Die obige Methode im Code ist die Methode in der NodeManager -Klasse, während die folgende Methode die Methode in der Knotenklasse ist.
Eine Root -Mitgliedsvariable wird in der Managerklasse bereitgestellt, mit der der Kopfknoten der verknüpften Liste verwaltet wird. Wenn Sie daher einen Knoten hinzufügen, wird zunächst festgelegt, ob die Wurzel leer ist. Wenn es leer ist, wird der Knoten direkt von der Wurzel gespeichert. Wenn das Root nicht leer ist, wird es in der Knotenklasse über die Methode addnode () hinzugefügt. Die Idee, zu dem Punkt hinzuzufügen, besteht darin, den letzten Knoten der aktuellen verknüpften Liste zu finden und der nächsten Mitgliedsvariable, die dem Knoten dem letzten Knoten zugeordnet ist, Neuzugang zuzuweisen.
Fügen Sie die verknüpfte Liste hinzu, löschen, ändern und überprüfen
Die gleiche Idee wird auch anderen Vorgängen auf verknüpften Listen gegeben. Der vollständige Code zum Hinzufügen, Löschen, Abrufen und Ausgang von verknüpften Listen ist wie folgt:
Klasse nodeManager {private Knoten root; // Root -Knoten private int currentIndex = 0; // Seriennummer der Knoten startet jede Operation mit 0 public void add (int data) {if (root == null) {root = new node (data); } else {root.addnode (Daten); }} public void delnode (int data) {if (root == null) return; if (root.getData () == data) {node tmp = root; root = root.Next; tmp = null; } else {root.delnode (Daten); }} public void print () {if (root! = null) {System.out.print (root.getData () + ""); root.printnode (); System.out.println (); }} public boolean findNode (int data) {if (root == null) return false; if (root.getData () == Daten) {return true; } else {return root.findnode (Daten); }} public boolean updateNode (int oldData, int newdata) {if (root == null) return false; if (root.getData () == OldData) {root.setData (newdata); zurückkehren; } else {return root.updatenode (oldData, newdata); }} // public void Insert (int Index, int data) {if (index <0) return; CurrentIndex = 0; if (index == currentIndex) {node newnode = new node (data); newnode.next = root; root = newnode; } else {root.insertNode (index, data); }} // Wer auch immer die Daten besitzt, wer den Methodenklassenknoten {private int Data; Privatknoten als nächstes; // Nehmen Sie den aktuellen Typ als öffentliche Node (int data) {this.data = data; } public void setData (int data) {this.data = data; } public int getData () {returndaten; } // Knoten public void addnode (int data) {if (this.Next == null) {this.next = new node (data); } else {this.next.addnode (Daten); }} // Löschen Sie den Knoten public void delnode (int data) {if (this.next! this.Next = this.next.Next; tmp = null; } else {this.next.delnode (Daten); }}} // Alle Knoten public void printNode () {if (this.Next! = Null) {System.out.print (this.Next.getData () + ""); this.next.printnode (); }} // Finden Sie, ob der Knoten existiert, öffentlich boolean findNode (int data) {if (this.Next! } else {return this.next.findnode (Daten); }} return false; } // den Knoten public boolean updateNode (int oldData, int newdata) {if (this.Next! zurückkehren; } else {return this.Next.UpDatenode (OldData, newdata); }} return false; } // Knoten public void InsertNode (int Index, int data) {currentIndex ++; if (index == currentIndex) {node newnode = new node (data); newnode.next = this.Next; this.Next = newnode; } else {this.Next.insertNode (Index, Daten); }}}}}Das obige ist der vollständige Code für den grundlegenden Betrieb der verlinkten Liste. Das Folgende ist ein Anrufcode zum Testen. Der Code lautet wie folgt:
public class linkList {public static void main (String [] args) {nodeManager nm = new nodeManager (); System.out.println ("Adresse der verknüpften Liste (fügen Sie 5, 4, 3, 2, 1)"); Nm.add (5); Nm.add (4); Nm.add (3); Nm.add (2); Nm.add (1); nm.print (); System.out.println ("Löschen der verknüpften Liste (löschen 3)"); Nm.delnode (3); nm.print (); System.out.println ("Suchliste der verknüpften Liste (Feststellung 1)"); System.out.println (Nm.findnode (1)); System.out.println ("Verknüpfungsliste (find 10)"); System.out.println (Nm.findnode (10)); System.out.println ("Aktualisierung (Aktualisierung 1 bis 10)"); nm.updatenode (1, 10); nm.print (); System.out.println ("Liste einfügen (in der ersten Position 20 einfügen)"); Nm.insert (1, 20); nm.print (); System.out.println ("Liste einfügen (in der ersten Position 30 einfügen)"); Nm.insert (1, 20); nm.print (); System.out.println ("Liste einfügen (liste einfügen (30 an der Nullposition)"); nm.insert (0, 30); nm.print (); }}Kompilieren und führen Sie den Code aus, das Ergebnis lautet wie folgt:
Ich habe viel Wissen über Datenstrukturen in der Sammelklasse in Java verwendet. Wenn ich in gutem Zustand bin, werde ich den Quellcode der Java -Sammlungsklasse lernen. Ich werde hart arbeiten, um ein Junior -Programmierer zu sein!
Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Referenzwert für das Studium oder die Arbeit eines jeden hat. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.