Verkettete Liste rückwärts ausgeben

[VansCat]

Wie kann ich die einfach verkettete Liste rückwärts?
Wo kann ich sie so umschreiben, dass die Ausgabe von hinten nach vorne erfolgt?

/*##########################################
 * 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 Java05a_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);
	}
}

 

[Natac]

Auf dem Weg zum letzen Element alle Element merken. Wenn du beim letzten Element angekommen bist, anfangen alle auszugeben (dann eben in umgekehrter Reihenfolge).

Anders kann es gar nicht gehen, da jedes Element nur das nächste kennt und du nur den Listenkopf zur Verfügung hast. Vielleicht ist es sinnvoll eine Methode "reverse" zu implementieren, die eine verkettete Liste umdreht.

 

[stg]

Man kann auch einfach eine simple Rekursion bemühen. Ich denke mal, dass die Übungsaufgabe darauf abzielen will. In PseudoCode läuft das dann in etwa so ab:

public void ausgaben() {
    if(next != null) {
        next.ausgeben();
    }
    System.out.println(this);
}

 

[VansCat]

Danke für Ihre mühe.
Leider verstehe ich nicht wo und wie kann ich den PseudoCode in meine Aufgabe erstellen. Es tut mir leid ich bin ganz Anfanger.