einfache Rekursion

[BlubBlub]

hi, ich bin mir bei einer sache unsicher, vielleicht könnt ihr mir da helfen.
wenn ich folgendes programm hab:

class Test
{

	public static void recurse(int deep)
	{	
		if(deep == 4){}
		else recurse(deep+1);
	}
	
	public static void main(String[] args) 
	{
		recurse(0);
	}

}

könnte ich ansstelle else recurse(deep+1) auch schreiben:

.....

else recurse(deep++);
....

wären dies exakt dieselben programme oder würde mir das recurse(deep++); bevor die methode ausgeführt wird, die variable deep auch noch hochsetzen. also nicht nur den parameter in der "neuaufgerufenen "funktion, sondern auch den in der "aktuell" befindlichen funktion. hoffe ich konnte das verständlich ausdrücken worum es mir geht.

 

[Ark]

Dann musst du [c]++deep[/c] verwenden. Allerdings klingt das überhaupt eher nach einem Designfehler.

Ark

 

[BlubBlub]

ok danke.

dann lass ichs bei deep+1.

class versuch
{

	public static void recurse(int deep)
	{
		System.out.println(deep);
		
		if(deep == 4){}
		else recurse(deep+1);
		
		System.out.println(deep);
	}
	
	public static void main(String[] args) 
	{
		recurse(0);
	}

}

was mich wunder ist, wenn ich dieses programm starte dann gibt es mir aus:
0
1
2
3
4
4
3
2
1
0


was ja auch logisch und nachvollziehbar ist.
wenn ich aber

recurse(deep++); mache gibt er mir aus:
0
0
0
0
0
.......


ich hätte wenn überhaupt erwartet, dass er mir ausgibt:

0
1
2
3
4
4
4
3
2
1

weil er meines achtens nach ja durch das deep++ den derzeitigen paramter auch hochsetzt bevor die funktion recurse(deep++) ausgeführt wird.
ich weiß nicht ganz wo mein denkfehler darin liegt.

 

[musiKk]

Na wie Ark geschrieben hat: Du bräuchtest Preinkrementoperator (was für ein tolles Wort) [c]++deep[/c]. In Deinem Beispiel wird erst die Methode ausgeführt und dann inkrementiert.

 

[BlubBlub]

löl preinkrementoperator ist echt nen geiles wort xD ....

nagut ich versteh schon was ich verwendent sollte, werd ich auch tun ...

ich kann nur die ausgabe nicht nachvollziehen, diesen preinkrementoperator nicht verwende, also die

0
0
0
0
0
0
....


anstelle von

0
1
2
3
4
4
4
3
2
1

aber dann nehm ichs einfach so hin und merke mir dass ich ++deep bzw. beeser deep+1 verwenden muss

 

[musiKk]

Na da sollte doch alles klar sein? Du rufst die Methode rekursiv immer wieder mit 0 auf, weil es immer wieder in den else-Zweig geht.

 

[BlubBlub]

ich schreib euch mal auf, wie ichs mir vorstelle, dass diese deep++ funktioniert und warum ich nicht verstehe dass da 0 0 0 0 0 ... ausgegeben wird.

class versuch
{
 
    public static void recurse(int deep) // 1.aufrur deep = 0 
    {
        System.out.println(deep); // ausgabe 0
        
        if(deep == 2){}
        else recurse(deep++); // deep = deep + 1 also deep = 0 + 1 somit deep = 1 ; ( auch obiges deep wird somit um eins raufgesetzt)
        
        System.out.println(deep);
    }
    
    public static void main(String[] args) 
    {
        recurse(0);
    }
 
}

 public static void recurse(int deep) // 2.aufrur deep = 1 
    {
        System.out.println(deep); // ausgabe 1
        
        if(deep == 2){}
        else recurse(deep++); // deep = deep + 1 also deep = 1 + 1 somit deep = 2
        
        System.out.println(deep);
    }

    public static void recurse(int deep) // 3.aufrur deep = 2
    {
        System.out.println(deep); // ausgabe 2
        
        if(deep == 2){}
        else recurse(deep++); 
        
        System.out.println(deep); //ausgabe 2
    }

    public static void recurse(int deep) //  zum 2.aufruf zurückgekehrt deep = 2  (deep nicht gleich 1. obwohl beim ersten 2.aufruf deep = 1 war; jetzt aber deep = 2 weil vor dem ausführen des 3. rekursiven aufrufs wurde deep = deep + 1 gerechnet also wurde diese variable erhöht)
    {
        System.out.println(deep); 
        
        if(deep == 2){}
        else recurse(deep++); //ab hier gehts weiter
        
        System.out.println(deep); // ausgabe 2
    }

    public static void recurse(int deep) // zum 1.aufruf zurückgekehrt deep = 1 (nicht 0 grund siehe oben) 
    {
        System.out.println(deep); 
        
        if(deep == 2){}
        else recurse(deep++); // ab hier gehts weiter
        
        System.out.println(deep); //ausgabe 1 
    }

rekursion abgearbeitet


ausgabe insgesamt:

0
1
2
2
2
1

so stelle ich mir die abarbeitung der rekursion vor, wenn man deep++ als parameter übergibt.
ich weiß dass da ein denkfehler ist aber ich weiß nicht genau worin.

 

[musiKk]

else recurse(deep++); // deep = deep + 1 also deep = 0 + 1 somit deep = 1 ; ( auch obiges deep wird somit um eins raufgesetzt)

Was hier passiert ist folgendes (und in genau in dieser Reihenfolge):
1. recurse wird mit deep (0) aufgerufen
2. deep wird um eins inkrementiert
In der erneut aufgerufenen Methode recurse ist deep also wieder 0 und das Spiel beginnt von vorne.

 

[BlubBlub]

ach so ist das also, nagut, dann versteh ichs jetzt.

danke für die hilfe

 

[Leroy42]

Was hier passiert ist folgendes (und in genau in dieser Reihenfolge):
1. recurse wird mit deep (0) aufgerufen
2. deep wird um eins inkrementiert
In der erneut aufgerufenen Methode recurse ist deep also wieder 0 und das Spiel beginnt von vorne.

Jau! Wenn das keine Endschlosschleife wäre, würden
beim Zurückkehren die zuvor erhöhten (lokalen) deep-Werte
ausgegeben.