Verkettete Liste

[Mitko]

Hallo,
mir liegt folgende Aufgabe vor. Ich habe lange Zeit versucht diese Aufgabe zu machen und habe einen Code programmiert bei dem Ich gemerkt habe, dass die Konsole das ausgegeben hat was ich auch brauche. Irgendwie habe ich aber das Gefühl, dass ich etwas extrem dummes zusammengebaut habe und das gar nicht die Lösung sein kann. Es scheint einfach falsch zu sein. Könnte mir jemand sagen ob meine Code richtig ist?

Erweitern Sie die zweite Version der einfach verketteten Liste so, dass das Listenende beim Anhängen nicht immer wieder neu ermittelt werden muss, sondern neue Elemente direkt am Ende der Liste angehängt werden können. Hängen Sie zum Test mindestens 20 Elemente an.
Dazu ein paar Hilfestellungen:
• Sie müssen neben dem Anfang der Liste jetzt auch das Ende der Liste in einer Variablen speichern können.
• Erstellen Sie eine Methode, die Ihnen das aktuelle Ende der Liste zurückliefert. Alternativ können Sie sich das Listenende auch von der Methode zum Anhängen liefern lassen.
• Setzen Sie den Wert der Variablen für das Listenende nach dem Anhängen neuer Elemente jeweils auf das aktuelle Ende der Liste und rufen Sie dann die Methode zum Anhängen neuer Listenelemente mit diesem Wert neu auf.

class Listenelement{
String daten; // Eigenschaft Daten
Listenelement nachfolger,Ende; // Zwei Listenelemente

void setDaten(String datenNeu) { // Übergabe von Daten

daten = datenNeu;

}

void anhangen(String datenNeu) {

if(nachfolger == null) { // Gibt es ein weiteres Element?
Ende = nachfolger; //Wenn ja dann Ende = nächstes Element
nachfolger = new Listenelement(); // Nachfolger erzeugt neues Objekt
nachfolger.setDaten(datenNeu); // Und gibt diesem Objekt daten

}
else // Wenn es kein weiteres Element gibt
nachfolger.Listenende(); // nachfolger ist gleich Ende
System.out.println(datenNeu); // Ende erzeugt 19 Elemente
}
Listenelement Listenende() { // Methode liefert Ende zurück
return Ende;
}

void ausgabe() { // Ausgabe von daten

System.out.println(daten); // Daten = Anfang "Element 1 "

}
}
public class Liste {

public static void main(String[] args) {

Listenelement Anfang = new Listenelement(); // Erzeugung von Anfang

Anfang.setDaten("Element 1"); // Anfang 1 zuweisen
Anfang.ausgabe(); // Anfang in der Konsole ausgeben
for(int e = 2;e < 21; e++) // Schleife für die Zahlen von 2 bis 20
Anfang.anhangen("Element "+e); // Anfang werden 19 Zahlen zugefügt


}
}

 

[KonradN]

Dazu kann ich erst einmal nur generelle Dinge sagen:

a) Code bitte immer in Code-Tags posten. Dazu einfach den Knopf </> links oberhalb des Eingabebereiches nutzen.

b) Beschreibe doch erst einmal, was Du genau machen willst. Derzeit ist die Liste, die Du da ansatzweise implementiert hast, schlicht unverständlich! Wie ist der Unterschied zwischen einer leeren Liste und einer Liste mit nur einem Element? Denn ganz offensichtlich generierst Du ein erstes Listenelement, das dann eine leere Liste sein könnte. Aber dann setzt Du da einfach "Element 1" und machst aus der Liste eine Liste mit einem Element? Das ist so unverständlich, denn es sollte ja einen Unterschied geben zwischen der leeren Liste und der Liste mit nur einem Element mit Wert null. (null ist ein gültiger Wert für eine String Variable, also könnte man den Wert auch in einer Liste mit Strings speichern!)

c) Coding Standards - Variablen sollten klein geschrieben werden, also statt Ende bitte ende.

d) Der Code ist so schlicht nicht in Ordnung:

if(nachfolger == null) {
    Ende = nachfolger; // Ende ist damit dann ja null!
    nachfolger = new Listenelement(); // hier wird nachfolger etwas zugewiesen - das ist dann aber nur in nachfolger!
    nachfolger.setDaten(datenNeu);
}

else // Wenn es kein weiteres Element gibt Hier fehlt offensichtlich die geschweifte Klammer auf - es kommen ja zwei Befehle....

Listenelement Listenende() { // Methode liefert Ende zurück Hier kommt dann die Klammer - aber natürlich an falscher Stelle ... Und was soll der Aufruf von Listenende() machen in Deinen Augen? Da wird ja einfach die Variable Ende zurück gegeben. Das verändert nichts. Und mit der Rückgabe machst Du nichts. Daher ein Befehl, der unter dem Strich einfach nichts macht!

Fazit
Ich vermute, dass Du hier also schlicht noch kein Verständnis hast, was denn da überhaupt passieren soll. Daher kann ich Dir nur ganz stark ans Herz legen: Nimm Dir Stift und Papier und male es Dir auf! Gehe im Detail durch, was Du denn an Verhalten erwartest. Das kann sein:

Leere Liste: Ein Listenelement mit nachfolger = null, ende = null.

Liste mit einem Element: Zwei Listenelement, erstes dann mit nachfolger und ende = dem zweiten Element und das Zweite Element hat die Daten aber dann mit nachfolger und ende = null.

Wenn dann noch ein Element dazu kommt, dann wird daraus:
Der Listenkopf hat nachfolger = erstes Element und ende = letztes Element
erstes Element hat Nutzdaten + nachfolger = zweites Element, ende = null
zweites Element hat Nutzdaten + nachfolger / ende = null

Das zeigt dann: ende wird nur im Listenkopf gesetzt. Innerhalb der Liste ist ende immer null! (Wäre dann ein Grund, das in zwei Klassen aufzuteilen: List hat dann keine Nutzdaten und Anfang und Ende. Die Listenelemente haben Nutzdaten und Nachfolger. Das aber nur als allgemeiner Hinweis.)

Und nun kannst Du Dir die einzelnen Möglichkeiten überlegen: Was für Fälle gibt es? Und was musst Du in jedem Fall im Detail machen? Das solltest Du anhand deiner Zeichnungen nachvollziehen können!