Gute tag
ich steh vor einem Problem:
Ich habe folgende Quellcodes
Dieser Code soll ergänzt werden Die Aufgabenstellung lautet so:
1: Erweitern sie die Version 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
Als zweites hab ich folgenden Code:
Hierzu hab ich folgende Aufgabe:
2: Erweitern Sie die Liste mit Objekten so das diese Liste auch rückwärts ausgegeben werden kann.
Erstellen sie dazu eine Methode die sich rekursiv aufruft
Zusätzlich wär ne kleine Erklärung gut wie der Code funktioniert denn ich steh bei den verketteten Listen ziemlich auf dem Schlauch. Das wurde nur einmal ganz kurz erläutert und ich habe es (leider) ÜBERHAUPT nicht verstanden. ;_(
Aber ich will ja auch verstehen was ihr da gemacht habt.. bzw. was ich machen soll ;-)
Danke schon mal im vorraus
gruß raver
ich steh vor einem Problem:
Ich habe folgende Quellcodes
Java:
/*######################################
* Eine verkettete Liste Version 2
######################################*/
//die Klasse für die Listenelemente
//jetzt auch mit Methoden
class Listenelement {
String daten;
Listenelement naechster;
//die Methode zum Setzen der Daten
void setDaten(String datenNeu) {
//die Zeichenkette setzen
daten = datenNeu;
//das Ende markieren
naechster = null;
}
//die Methode zum Anhängen eines neuen Elements
//sie ruft sich rekursiv auf, bis das Ende erreicht ist
void anhaengen(String datenNeu) {
//wenn das Ende erreicht ist, ein neues Element erzeugen
if (naechster == null) {
naechster = new Listenelement();
naechster.setDaten(datenNeu);
}
//sonst ruft sich die Methode selbst wieder auf
else
naechster.anhaengen(datenNeu);
//nur zur Veranschaulichung
System.out.println("Daten " + datenNeu + " wurden eingefügt.");
}
//die Methode zur Ausgabe der Liste
//sie ruft sich ebenfalls rekursiv auf, bis das Ende erreicht ist
void ausgeben() {
System.out.println(daten);
if (naechster != null)
naechster.ausgeben();
}
}
public class Java05_10 {
public static void main(String[] args) {
//ein neues Listenelement erzeugen
Listenelement listenAnfang = new Listenelement();
//die Daten im ersten Listenelement setzen
listenAnfang.setDaten("Element 1");
//weitere Elemente in einer Schleife einfügen
for (int element = 2; element < 4; element++)
listenAnfang.anhaengen("Element " + element);
//die Liste ausgeben
listenAnfang.ausgeben();
}
}
Dieser Code soll ergänzt werden Die Aufgabenstellung lautet so:
1: Erweitern sie die Version 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
Als zweites hab ich folgenden Code:
Java:
/*##########################################
* Eine verkettete Liste Version 1
############################################ */
//die Klasse für die Listenelemente
//Sie enthält nur Instanzvariablen für die Daten und den
//Nachfolger, aber keine Methoden
class Listenelement {
String daten;
Listenelement naechster;
}
public class Java05_09 {
//Klassenmethoden für die Verarbeitung der Liste
//die Daten für ein Element setzen
//übergeben wird die Zeichenkette und das Element der Liste
static void setDaten(String datenNeu, Listenelement element) {
//die Zeichenkette setzen
element.daten = datenNeu;
//das Ende markieren
element.naechster = null;
}
//eine neues Element am Ende der Liste einfügen
//übergeben wird die Zeichenkette und der Listenanfang
//das eigentliche Einfügen erfolgt über die Methode setDaten()
static void listeAnhaengen(String datenNeu, Listenelement listenAnfang) {
//eine Hilfskonstruktion zum Wandern in der Liste
Listenelement hilfsKonstruktion;
hilfsKonstruktion = listenAnfang;
//durch die Liste gehen, bis das Ende erreicht ist
while (hilfsKonstruktion.naechster != null)
hilfsKonstruktion = hilfsKonstruktion.naechster;
//neues Element am Ende der Liste einfügen
hilfsKonstruktion.naechster = new Listenelement();
//Hilfskonstruktion auf das neue Element setzen
hilfsKonstruktion = hilfsKonstruktion.naechster;
//die Daten eintragen
setDaten(datenNeu, hilfsKonstruktion);
}
//die Ausgabe der kompletten Liste
static void listeAusgeben(Listenelement listenAnfang) {
//die Hilfskonstruktion
Listenelement hilfsKonstruktion;
hilfsKonstruktion = listenAnfang;
//erstes Element ausgeben
System.out.println(hilfsKonstruktion.daten);
//und nun den Rest
while (hilfsKonstruktion.naechster != null) {
hilfsKonstruktion = hilfsKonstruktion.naechster;
System.out.println(hilfsKonstruktion.daten);
}
}
public static void main(String[] args) {
//ein neues Listenelement erzeugen
Listenelement listenAnfang = new Listenelement();
//die Daten im ersten Listenelement setzen
setDaten("Element 1", listenAnfang);
//weitere Elemente in einer Schleife einfügen
for (int element = 2; element < 4; element++)
listeAnhaengen("Element " + element, listenAnfang);
//die Liste ausgeben
listeAusgeben(listenAnfang);
}
}
Hierzu hab ich folgende Aufgabe:
2: Erweitern Sie die Liste mit Objekten so das diese Liste auch rückwärts ausgegeben werden kann.
Erstellen sie dazu eine Methode die sich rekursiv aufruft
Zusätzlich wär ne kleine Erklärung gut wie der Code funktioniert denn ich steh bei den verketteten Listen ziemlich auf dem Schlauch. Das wurde nur einmal ganz kurz erläutert und ich habe es (leider) ÜBERHAUPT nicht verstanden. ;_(
Aber ich will ja auch verstehen was ihr da gemacht habt.. bzw. was ich machen soll ;-)
Danke schon mal im vorraus
gruß raver
Zuletzt bearbeitet: