Die Codekopie lautet wie folgt:
/**
* One-Way-Linked List
*
*/
öffentliche Klasse nodelist <e> {
private statische Klassenknoten <e> {// Knotenklasse
E Daten; // Daten auf dem Knoten
Knoten <e> als nächstes auf den nächsten Knoten zeigen
Knoten (e e) {
this.data = e;
this.Next = null;
}
}
privater Knoten <e> Kopf;
privater Knoten <e> letztes;
private Knoten <e> other = null;
private int länge = 0 // Anzahl der Knoten
/**
* Nicht-Parameter-Konstruktionsmethode
*/
public nodelist () {
// Der Standardknoten ist leer
this.head = new node <e> (null);
}
/**
* Erstellen Sie während der Initialisierung einen Knoten
*
* @param Daten
* Daten
*/
public nodelist (e data) {
this.head = new node <e> (Daten);
this.last = Kopf;
Länge ++;
}
/**
* Fügen Sie einen Knoten hinzu (Schwanzinsertionsmethode)
*
* @param Daten
* Daten
*/
public void add (e data) {
if (isempty ()) {
head = neuer Knoten <e> (Daten);
last = Kopf;
Länge ++;
} anders {
Knoten <E> newnode = neuer Knoten <e> (Daten);
last.Next = newnode;
last = newnode;
}
}
/**
* Holen Sie sich die Daten im Index (Indexeingangsfehler löst eine Ausnahme außerhalb der Untergrabungen aus)
* @param Index Index
* @return Daten unter dem Index
*/
public e get (int index) {
if (index <0 || index> länge) {
Neue IndexoutOfBoundSexception ("Index:"+Index);
}
andere = Kopf;
für (int i = 0; i <index; i ++) {
Andere = andere.Next;
}
kehre andere zurück.data;
}
/**
* Neuer Wert ersetzt den alten Wert
* @return Erfolg ist wahr, nicht als falsch gefunden
*/
public boolean set (e oldvalue, e newValue) {
andere = Kopf;
while (other! = null) {
if (other.data.equals (OldValue)) {
other.data = newValue;
zurückkehren;
}
Andere = andere.Next;
}
false zurückgeben;
}
/**
* Fügen Sie ein Element ein, nachdem Sie das Element angegeben haben
*
* @param Daten
* Angegebenes Element
* @param InsertData
* Elemente, die eingefügt werden müssen
* @return false ist Element nicht gefunden, wahr ist ein Einfügen erfolgreich
*/
public boolean add (e data, e insertData) {
andere = Kopf;
while (other! = null) {
if (other.data.equals (Daten)) {
Knoten <E> newnode = neuer Knoten <E> (InsertData);
Knoten <e> temp = other.next;
newnode.next = temp;
other.Next = newnode;
Länge ++;
zurückkehren;
}
Andere = andere.Next;
}
false zurückgeben;
}
/**
* Ob dieses Element in der verlinkten Liste enthalten ist
* @return als wahr eingeschlossen, nicht falsch
*/
public boolean enthält (e data) {
andere = Kopf;
while (other! = null) {
if (other.data.equals (Daten)) {
zurückkehren;
}
Andere = andere.Next;
}
false zurückgeben;
}
/**
* Entfernen Sie das angegebene Element
* @Param -Datenelemente, die entfernt werden müssen
* @Return existiert nicht und gilt für den Erfolg
*/
public boolean remove (e data) {
andere = Kopf;
Knoten <e> temp = Kopf; // Temporäre Variable, zum Speichern des vorherigen Knotens verwendet
while (other! = null) {
if (other.data.equals (Daten)) {
temp.Next = other.next;
Länge--;
zurückkehren;
}
temp = andere;
Andere = andere.Next;
}
false zurückgeben;
}
/**
* Bestimmen Sie, ob die verknüpfte Liste leer ist
*
* @return leer ist wahr, nicht leer ist falsch
*/
public boolean isempty () {
Rücklauflänge == 0;
}
/**
* Löschen Sie die Linkliste
*/
public void clear () {
this.head = null;
this.length = 0;
}
/**
* Alle Knoten ausgeben
*/
public void printlink () {
if (isempty ()) {
System.out.println ("leere verlinkte Liste");
}anders{
andere = Kopf;
while (other! = null) {
System.out.print (other.data);
Andere = andere.Next;
}
System.out.println ();
}
}
}