# Rekursion



## sphonix (21. Mrz 2015)

Hallo Leute,

ich arbeite mich grade in Java ein und habe am Montag ein Testat. Ich bin ehrlich gesagt kein Java-Naturtalent und es fällt mir etwas schwer mich in das Thema Rekursion einzurbeiten.

Ich habe hier eine Aufgabe bei der ich gar nicht weiterkomme. Im Anhang ist die Aufgabenstellung abfotografiert.

für den Aufgabenteil a) bin ich nur soweit gekommen, dass ich weiß (hoffentlich auch richtig!), was im Allgeminen gemacht werden muss:

Mitarbeiter findeMalocher(){
	Mitarbeiter fund = this.name;
	for(Mitarbeiter m : untergebene){
		...
	}
	return fund;
} 

Aber jetzt weiß ich nicht wie ich weiter machen soll? Woher erkenne ich wann ich keine Untergebenen mehr habe? Kann jemand von euch mir die Lösung z Aufgabenteil a) erklären? Danach denke ich, dass ich b) selbstständig lösen müssen sollte.

Viele Grüße


----------



## Gucky (22. Mrz 2015)

Rekursiv bedeutet "sich selbst aufrufend". Du hast bisher nur eine iterative Lösung.

Du durchläufst die ArrayList mit einer for-each Schleife. Auf jedes Mitarbeiter Objekt rufst du findeMalocher auf.
Was genau gesucht ist, weiß ich nicht, weshalb ich diesen Fall annehme: gesucht sind die Mitarbeiter Objekte, die einen Malocher beschreiben.
Wird ein Malocher gefunden (untergebene.size() = 0), so fügst du ihn einer lokalen ArrayList hinzu. Am Ende der Methode gibst du die ArrayList zurück.
Die aufrufende Methode findeMalocher fügt diese Liste ihrer eigenen Liste hinzu und das Ganze geht von vorne los.


Oder in Pseudocode:

```
ArrayList<Mitarbeiter> findeMalocher(){
  ArrayList<Mitarbeiter> malocher = new ...
  if (Untergebene){
    for(Mitarbeiter arb : untergebene){
      malocher.addAll(arb.findeMalocher());
    }
  }
  else untergebene.add(this)
  return malocher
}
```

Da ist noch Optimierungspotential, sodass du pro Malocher einen Methodenaufruf sparen kannst aber das überlasse ich dir


----------



## sphonix (22. Mrz 2015)

Danke für deine Antowort. Irgendwie erschließt sich mir das jedoch nicht ganz :s

Wenn ich das versuche durchzugehen dann habe ich doch folgendes und bitte korregiert mich falls ich das Prinizp falsch verstehe:

Die ArrayList untergebene beinhaltet doch die untergebenen Mitarbeiter von Aaron. Das sind Berta und Bruno. Bertra hat doch wiederrum eigene Untergebene. Das heißt ich habe hier eigentlich 2 ArrayListen von Typ Mitarbeiter. Einmal Eine Liste von Untergebene Aarons und eine von Bertas. Oder werden alle in eine ArrayList abgespeichert?

Jetzt übergebe ich als erstes die ArrayList untergebene in die Methode:

```
ArrayList<Mitarbeiter> findeMalocher(ArrayList untergebene){
```

und erstelle eine neue ArrayList malocher:

```
ArrayList<Mitarbeiter> malocher = new ...
```

was sagt mir die if-Schleife aus? 

In der For-Schleife, überprüfe ich jedes Objekt vom Typ Mitarbeiter

```
for(Mitarbeiter arb : untergebene){
```

ich verstehe jetzt, dass ich mit 

```
malocher.addAll(arb.findeMalocher());
```
das Objekt in die letzte Position von malocher schiebe (in dem Fall Bertra) und ihre (Bertras) untergebene ArrayList mit der Methode nochmal aufrufe! Richtig?

Was macht dann hier

```
else untergebene.add(this)
```
 ?


----------



## Gucky (22. Mrz 2015)

Guck erstmal hier.

Warum übergibst du der Methode die ArrayList, auf die sie sowieso zugreifen kann?

Die mehreren ArrayLists werden mit addAll erledigt. Das fügt die zurückgegebene ArrayList der lokalen ArrayList hinzu.

Wenn ein Mitarbeiter keine Untergebenen hat, ist er selbst ein Malocher. Deshalb fügt er sich selbst im else Block der ArrayList hinzu und gibt diese zurück.


Ich meine aus deiner Verwirrung mit den multiplen ArrayLists zu ersehen, dass du das Konzept von Objekten noch nicht ganz verstanden hast.
Du hast ein Objekt O1 und eines O2.
Dann rufst du O1.setWert(3); und O2.setWert(7); auf.
setWert sieht so aus:

```
void setWert(int wert){
  this.wert = wert;
}
```
und obwohl beide Methoden auf eine Variable gleichen Namens und Typs zugreifen und beide Objekte derselben Klasse entstammen, sind es zwei Variablen. Die eine hat den Wert 3 und die andere den Wert 7.


----------



## sphonix (22. Mrz 2015)

Okay. Danke dir!

Ich habe mal Teil b) gemacht. Stimmt das so?


```
int berechneTeamgehalt(){
	int summe = this.gehalt;
	for (Mitarbeiter m : untergebene){
		summe += m.berechneTeamgehalt();
	}
	return summe;
}
```


----------



## Flown (23. Mrz 2015)

Probiers doch aus, du hast ja eh Testbeispiele bekommen. Sind die richtig?


----------



## sphonix (23. Mrz 2015)

Leider nein


----------



## Flown (23. Mrz 2015)

Also ich kann dir nur sagen, wenn du die Hierarchie richtig aufgebaut hast, dann kommt das richtige raus.


----------



## sphonix (23. Mrz 2015)

Okay danke. 

Wie sieht es eigentlich aus, wenn ich das etwas modifiziere und das höchste und niedrigste Gehalt ausgeben möchte.

Sage ich in dem Fall folgendes:


```
void berechneTeamgehalt(){
	int summe = this.gehalt;
	for (Mitarbeiter m : untergebene){
		if (m > summe){
			int summeMax = m;
		} else if (m < summe){
			int summeMin = m;
		   }
		m.berechneTeamgehalt();
	}
	System.out.println("Höchstes Gehalt: " + summeMax);
	System.out.println("Niedrigstes Gehalt: " + summeMin);
}
```

? Oder geht das auch eleganter?


----------



## VfL_Freak (23. Mrz 2015)

Moin,
schau mal genau, was Du da vergleichst !!


sphonix hat gesagt.:


> ```
> void berechneTeamgehalt()
> {
> int summe = this.gehalt;
> ...



Gruß Klaus

BTW: JAVA-Tags sind hier deutlich geeigneter als CODE-Tags !!


----------



## Flown (23. Mrz 2015)

Poste doch alle Aufgabenstellungen. Muss denn alles mit Rekursion gebaut werden?

Das was du gepostet hat funktioniert so nicht, aber das wirst du wohl schon noch bemerken.


----------



## sphonix (23. Mrz 2015)

Das ist ALLES was an Aufgabenstellung gegeben ist!

@Klaus: Ich seh's. Nicht grade logisch 

Als Lösungsvorschlag würde ich einen temporären Wert int einfügen, der sie summe speichert und mit neuen werten vergleicht


```
void berechneTeamgehalt() {
	int summe = this.gehalt;
	int summeMax = 0;
	int summeMin = 0;
	for (Mitarbeiter m : untergebene) {
		if (summeMax < summe) {
			summeMax = summe;
		} else if (summeMin > summe) {
			summeMin = summe;
		   }
		m.berechneTeamgehalt();
	}
	System.out.println("Höchstes Gehalt: " + summeMax);
	System.out.println("Niedrigstes Gehalt: " + summeMin);
}
```


----------



## Flown (23. Mrz 2015)

In der Angabe steht nichts von einem einer Berechnung des Maximum oder Minimum.


----------



## sphonix (23. Mrz 2015)

Soll ja auch nur eine für mich selber als Verständnis dienen. Nur dafür jetzt einen extra Thread zu eröffnen ist doch umständlich.


----------

