# rekursive Listen in Java?



## Arlic (12. Feb 2010)

Hi

ich versuch mich grad an einer rekursiven Liste in Java und habe dazu zwei Klassen erstellt. Nur weiß ich einfach nicht, ob das so funktioniert wie ich mir das vorstelle...



```
public class Listenwert {
	public int wert;
	public Listenwert next;
	
	public Listenwert(int wert, Listenwert next){
		this.wert=wert;
		this.next=next;
	}
}
```


```
public class Liste {
	protected static Listenwert liste = new Listenwert (0, null);
	
	public void fuegeEin(int x){
		if (liste.next==null && liste.wert==0){
			Listenwert liste = new Listenwert (x, null);
		}else{
			Listenwert neu = new Listenwert (x, liste.next);
			liste.next = neu;
		}
	}
	
}
```

Also ich möchte im Moment einfach nur neue Elemente in eine Liste einfügen können. Geht das so? Also steckt der richtige Gedankengang dahinter? Wenn nicht wäre ich für einen Tipp dankbar 

Danke schon mal
mfg
Arlic

Edit: Ich könnte natürlich noch sagen was ich mir dabei gedacht habe 
also: In der ersten Klasse sind die Eigenschaften der Liste definiert. In der zweiten soll dann zunächst eine Liste erstellt werden und durch die Methode fuegeEin ein neuer Integer Wert in die Liste eingefügt werden (oh wunder  ). Wenn die Liste bislang leer ist wird das erste Element überschrieben, wenn sie nicht leer ist wird an das erste Element das Element neu drangehangen was den neuen Wert beinhalten soll


----------



## Murray (12. Feb 2010)

Du erzeugst beim Einfügen im ersten Fall ein neues Objekt, welches aber nur in einer lokalen Variablen gespeichert ist. Vermutlich willst du in Zeile 7 das neue Objekt eher der Membervariablen liste zuweisen, oder?

Warum ist die Membervariable liste static? Damti teilen sich alle Instanzen deiner Liste die gleichen Daten.


----------



## ARadauer (12. Feb 2010)

beschreib mal was der Code machen soll....
wenn liste.next null dann wird ein neuer Listenwert erzeugt ... mit dem aber dann nichts gemacht wird.. 
wenn liste.next nicht null, wird dieses next mit einem neuen Listenwert überschrieben... nein das machst du falsch.....

eher so... ungegetestet


```
Listenwert current = liste;
      Listenwert neu = new Listenwert (x, liste.next);

      if(current==null){
         current = neu;
         return;
      }

      while(current.next != null){ //das letzte element suchen, das Letze ist es wenn next null
         current = current.next;   //also so lange next nicht null, nächstes anschaun
      }
      current.next = neu; //beim letzen nun die neue einfügen
```


----------



## Murray (12. Feb 2010)

ARadauer hat gesagt.:


> wenn liste.next nicht null, wird dieses next mit einem neuen Listenwert überschrieben... nein das machst du falsch.....


So ganz falsch ist das doch nicht: das alte liste.next ist dann ja neu.next; es geht in dem Fall also nichts verloren. Allerdings werden die Elemente so immer vorne einsortiert.


----------



## Arlic (13. Feb 2010)

Murray hat gesagt.:


> So ganz falsch ist das doch nicht: das alte liste.next ist dann ja neu.next; es geht in dem Fall also nichts verloren. Allerdings werden die Elemente so immer vorne einsortiert.



Ja das stimmt. Ich hab mir mit einer forschleife die Zahlen 1-9 in die Liste geschrieben und das sah dann halt so aus 198... allerdings gabs einen Fehler in Zeile 7 wo ich mir nochmal eine neue Liste erstellte, was nicht sein durfte. Hab nochmal ein wenig weiter gemacht und jetzt müssten die neuen Elemente immer vorne eingefügt werden.


```
public class Liste {
	protected static Listenwert listenelement = new Listenwert (0, null);
	
	public void fuegeEin(int x){
		if (listenelement.next==null && listenelement.wert==0){
			listenelement = new Listenwert (x, null);
		}else{
			Listenwert neu = new Listenwert (x, listenelement);
			listenelement = neu;
		}
	}
	
	public void print(){
		Listenwert neu;
		neu = listenelement;
		if (listenelement.next==null){
			System.out.println("null "+listenelement.wert);
		}
		while(neu.next!=null){
			System.out.print(neu.wert);
			neu = neu.next;
			if(neu.next==null){
				System.out.print(neu.wert);
			}
		}
	}
	
}
```


----------



## Arlic (13. Feb 2010)

Da das erste jetzt klappt hab ich mir das jetzt mal versucht mit getter und setter zu schreiben

aber die print() funktion will nicht so wie ich will... aus irgendeinem Grund läuft sie nicht richtig durch und ich versteh nicht warum. Die fuegevorneEin Methode stimmt glaube ich.


Konstruktor für die Liste (nennt man das so?  ):
[Java]

public class Liste {
	private int wert;
	private Liste next;

	public Liste(int wert, Liste next){
		this.wert=wert;
		this.next=next;
	}
	public int getWert(){
		return this.wert;
	}
	public void setWert(int x){
		this.wert=x;
	}
	public Liste getNext(){
		return this.next;
	}
	public void setNext(Liste n){
		this.next=n;
	}
}

[/code]


die Listenmethoden:


```
public class kopf {
	Liste element = new Liste(0, null);
	
	public void fuegevorneEin(int x){
		if(element.getNext()==null && element.getWert()==0){
			this.element.setWert(x);
		}else{
			Liste neu = new Liste(x, element);
			neu.setNext(element);
		}
	}
	
	public void print(){
		if (element.getNext()==null){
			System.out.print("null "+element.getWert());
		}
		while(element.getNext()!=null){
			System.out.print(element.getWert());
			element= element.getNext();
		}
	}
}
```


meine main class die ich zum testen benutzen will:


```
public class start {
	public static void main (String[] args){
		kopf liste = new kopf();
		
		for(int c=0; c<10; c++){
			liste.fuegevorneEin(c);

		}
		liste.print();
	}
}
```


----------

