# verkettete liste



## raver1 (15. Okt 2010)

Gute tag

 ich steh vor einem Problem:

Ich habe folgende Quellcodes 
	
	
	
	





```
/*######################################
 * 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:


```
/*##########################################
 * 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


----------



## Marcinek (15. Okt 2010)

Das prinzip  ist mit bissel googeln schnell gefunden.

Besser, als wenn man es hier erklärt:

Das Prinzip ist einfach --> Du hast ein Item, welches auf das nächste zeigt.

Item  --> Item --> Item 

Wenn du nun hier ein neues Item hinzufügen willst, dann musst du das letzte Item identifizieren, also von vorne bis hinten durchlaufen und solange bis Item.next == null (also er zeigt auf nix)

Um das abzukürzen kannst du dir das letze Item immer merken.

Bei der doppel verkettung zeigt das Item auf den nächsten und vorgänger.

Bei der Rekursion wird zunächst nach unten iteriert und dann werden die Items bei dem letzten  aufruf der Methode ausgegeben.. Dann erscheint die Liste rückwärts.

Gruß,

Marcinek


----------



## raver1 (15. Okt 2010)

okay..soweit hab ich das verstanden ;_)

Jetzt brauch ich nur noch Hilfe bei den Aufgaben. weil ich gerade nicht weiß wie ich das in Java umsetzen kann trotzdem danke


----------



## Marcinek (16. Okt 2010)

Ich würde (in diesem Fall) in Listenelement statisch das letzte Element abspeichern.

und anhängen würde immer an dieses Element anhängen und dann das statische Element ersetzen.

---

Bei dem anderen brauchst du eine Rekursive Methode

```
static void listeAusgebenRek(Listenelement listenAnfang) {
    if(listenAnfang.next != null) {
          listeAusgebenRek(listenAnfang.next);
     } 

      // Ausgeben
}
```


----------



## raver1 (16. Okt 2010)

Danke für die Antwort

Die rekursive Methode hab ich verstanden und auch eingefügt

Jedoch ist mir nicht ganz klar wie das mit der statischen Speichermethode bzw. dem Elemente anhängen gemeint ist bzw wie ich das in Java schreiben soll.

Da ich aber in dieser Woche noch damit fertig sein muss und auch nicht das ganze Wochenende dafür opfern kann ;-) würde ich euch/dich bitten mir mal den Code für meine Aufgabenstellung zu schicken
wenn ihr/du Zeit habt/hast. ;-)

Das wär echt nett und sobald ich das geschafft habe lern ich auch noch mal ;-)

Danke schon mal

raver


----------



## Marcinek (16. Okt 2010)

Ich formuliere es anders:

Wieviel ist dir das Wert? (In €)


----------

