package listen_sortieren_suchen; /* AUFGABE 62 (Klasse umbenannt) */ public class Listenelement { private final int wert; private Listenelement naechster; public Listenelement(int e) { this(e, null); } public Listenelement(int e, Listenelement naechster) { this.wert = e; // e in dem Attribut wert speichern this.naechster = naechster; // Parametervariable naechster in Attribut naechster speichern } /** Fügt den Wert hinten an die Liste an. */ public void einfuegen(int wert) { if (naechster != null) // -> ich bin nicht das letzte Element der Liste naechster.einfuegen(wert); // delegiere Aufgabe (Hinten Einfügen) an meinen Nachfolger else // -> ich bin das letzte Listenelement naechster = new Listenelement(wert); // erzeuge neues Listenelement mit dem Wert und setze es als meinen Nachfolger } /** Entfernt das erste Vorkommen von in der Liste und gibt das neue erste Element (head) zurück. */ public Listenelement entfernen(int wert) { if (this.wert != wert) { // -> aktuelles Element soll nicht gelöscht werden Listenelement neuerNaechster; neuerNaechster = naechster.entfernen(wert); // delegiere Aufgabe an Nachfolger, speichere dessen "Erstes" (er selbst oder sein Nachfolger) naechster = neuerNaechster; // setze meinen Nachfolger auf das "neue erste Element" des Nachfolgers (ggf. er selbst, d. h. dann unverändert) return this; // Listenelement gibt sich selbst zurück, soll also nach wie vor Nachfolger des bisherigen Vorgängers bleiben } else // -> aktuelles Element soll entfernt werden return naechster; // Der Nachfolger meines Vorgängers soll auf meinen Nachfolger gesetzt werden } /** Gibt eine kommagetrennte String-Repräsentation der Liste zurück (bspw. "1, 2, 4, 5"). */ public String toString() { String result = ""; result += this.wert; // zunächst kommt mein eigenes Element (z. B. 1) if (naechster != null) { // -> Nachfolger existiert result += ", "; // Komma nur anhängen, wenn es nötig ist (Nachfolger existiert) String restListe = naechster.toString(); // String-Repräsentation der Rest-Liste (alles nach mir selbst) per Delegation an Nachfolger result += restListe; // diese Repräsentation einfach anhängen (z. B. "2, 4, 5") } return result; } public boolean equals(Object o) { if (o.getClass() != this.getClass()) { //if (o instanceof Listenelement == false) { // -> ist kein Listenelement (z. B. ist ein String oder ein int-Array) return false; // kann also nicht gleich sein } else { // -> ist ein Listenelement Listenelement o_ = (Listenelement) o; // Casten, damit ich vollen Zugriff auf alle Methoden in Listenelement habe if (this.wert != o_.wert) { // -> Mein Wert ist ungleich dem Wert des anderen Listenelements return false; // Listenelemente sind also nicht gleich } else { // -> Werte sind gleich (passt also soweit) if (this.naechster == null) { // -> aktuelle Liste ist zu Ende if (o_.naechster == null) { return true; // beide Listen sind zu Ende (und waren bisher gleich, sonst hätten wir längst false zurückgegeben) } else { return false; // this ist zu Ende, aber o_ hat noch Element(e) } } else { return naechster.equals(o_.naechster); // Delegiere Vergleichsaufgabe an das Nachfolgerelement (jeweils) } } } } // Test public static void main(String[] args) { Listenelement x = new Listenelement(1); x.einfuegen(6); x.einfuegen(4); x.einfuegen(2); x.entfernen(6); x.einfuegen(5); System.out.println(x); Listenelement y = new Listenelement(1); y.einfuegen(4); y.einfuegen(2); y.einfuegen(5); System.out.println(y); System.out.println(x.equals(y)); } }