Verständnis zu einem Rekursionsbeispiel

[easyJAVA?]

Hallo,

public static void main(String[] args){
		        rekursion(4);
		    }
		    public static void rekursion(int a){
		       a--;
		        System.out.println(a);
		        if (a!=0) rekursion(a);
		        System.out.println(a);
}

Ausgabe ist
3
2
1
0 und bis hier hin verstehe ich warum das ausgegeben wird.
0 ab hier nicht mehr.
1
2
3

Warum wird die 0 nochmal ausgegeben und warum wird wieder hochgezählt? ist ja ganz klar ein a--

Danke.

 

[Michael...]

Hoffe der Code ist bei Dir besser eingerückt.

Gehe doch einfach mal den Ablauf im Kopf oder auf Papier durch.
- die Methode wird mit einem Wert aufgerufen
- der übergebene Wert (Kopie des Wertes) wird um eins reduziert und ausgegeben.
- falls der Wert nicht 0 ist wird die Methode rekursiv aufgerufen.
Dadurch kommt es zu der für Dich noch verständlichen Ausgabe von 3, 2, 1, 0

Allerdings ist damit die Methode noch nicht fertig. Wenn der rekursive Aufruf abgeschlossen ist wird der ursprüngliche Wert ja nochmals ausgegeben daher das 0, 1, 2, 3

 

[easyJAVA?]

Allerdings ist damit die Methode noch nicht fertig. Wenn der rekursive Aufruf abgeschlossen ist wird der ursprüngliche Wert ja nochmals ausgegeben daher das 0, 1, 2, 3

Warum? In welcher Zeile ist das definiert?

 

[Kiri]

    public static void rekursion(int a){
        a--;
        System.out.println(a);
        
        if (a!=0){
            rekursion(a);
        }
        //nach der rekursion
        System.out.println(a);
    }

 

[Michael...]

Warum? In welcher Zeile ist das definiert?

In Zeile 8.

 

[stikio]

Gehe doch einfach mal den Ablauf im Kopf oder auf Papier durch.

den rat solltest du dir zu herzen nehmen, solch einfache beispiele solltest du schon früh verstehen, sonst versteht man dinge die auf sowas aufbauen nicht mehr.

schreib dir einfach auf papier auf wie die schleife durchlaufen wird und du lernst zimelich viel, wie das ganze funktioniert

 

[VfL_Freak]

Moin,

vielleicht wird es ja klarer, wenn Du in Deinem Code mal 'ne Klammer setzt :

public static void rekursion( int a )
{
    a--;
    System.out.println( a );
    if( a!=0 ) 
    { // !!
        rekursion( a );
    } // !!

    System.out.println(a);
}

Gruß
Klaus

 

[MarderFahrer]

Solange man nicht schon vorher weiß, wie rekursion funktioniert, wird einem auch das durchgehen auf Papier nicht viel bringen.

Damit kommt man nämlich genausoweit, wie der TO es bereits beschrieben hat. Da nützen auch die extra Klammern nichts, da dieser Teil des Codes bereits vom TO verstanden wurde.
Geht man die Methode Zeilenweise durch, so kommt man so weit:
3
2
1
0

An dieser Stelle müsste man wieder bei der If-Anweisung sein. Und diesmal ist sie nicht True, da a==0 ist.
Also wird die Methode nicht erneut aufgerufen.
Und wenn man jetzt nicht weiß, wie Rekursion funktioniert, kommt man Zeilenweise auf Papier nur noch zu einer System.out.println Anweisung und dann ist die Methode Augenscheinlich zu Ende und das Programm "sollte" anhalten.

Erst im Debugger sieht man, dass diese letzte System.out zusätzlich noch drei mal aufgerufen wird.
Ich wüsste nicht, wie man sich das selbst beibringen sollte, indem man das ganze auf Papier durchgeht.

 

[Landei]

rekursion(4)

bewirkt folgendes:

println(3) //in rekursion(4)
rekursion(3) //in rekursion(4)
println(3) //in rekursion(4)

Verfolgt man den Aufruf von rekursion(3) weiter, hat man:

println(3) //in rekursion(4)
println(2) //in rekursion(3)
rekursion(2) //in rekursion(3)
println(2) //in rekursion(3)
println(3) //in rekursion(4)

Verfolgt man den Aufruf von rekursion(2) weiter, hat man:

println(3) //in rekursion(4)
println(2) //in rekursion(3)
println(1) //in rekursion(2)
rekursion(1) //in rekursion(2)
println(1) //in rekursion(2)
println(2) //in rekursion(3)
println(3) //in rekursion(4)

Verfolgt man den Aufruf von rekursion(1) weiter, hat man:

println(3) //in rekursion(4)
println(2) //in rekursion(3)
println(1) //in rekursion(2)
println(0) //in rekursion(1)
//if-Bedingung trifft nicht mehr zu in rekursion(1)
println(0) //in rekursion(1)
println(1) //in rekursion(2)
println(2) //in rekursion(3)
println(3) //in rekursion(4)

Alles klar?

 

[Rallenaldo]

Sorry das ich den Thread nochmal hochhole, aber ich wollte keinen neuen starten.

Ich hab das Beispiel soweit glaube ich verstanden.

Es werden die Zahlen 321 ausgegeben, weil das die erste Print-Anweisung ausgeben soll.
Die 2. Anweisung ist dann die if Anweisung, die sagt, dass rekursion(a) nochmals gestartet werden soll, wenn Variable "a" ungleich 0 ist.

Wenn n==0 ist, ist der Ausstiegspunkt erreicht und es soll erneut die Variable "a" ausgegeben werden.

Da "a" aber inzwischen mehrere Werte hatte, gibt er diese Werte alle nochmals aus und beginnt bei dem Wert, den "a" als letztes hatte.

Hab ich das richtig verstanden?

 

[hüteüberhüte]

Naja, es werden nacheinander die gleiche Methode nochmals aufgerufen, immer mit neuen Werten.

Aufruf 1: a==3, sout(3), weiter mit Aufruf 2, danach sout(3),
Aufruf 2: a==2, sout(2), weiter mit Aufruf 3, danach sout(2),
Aufruf 3: usw.

Jetzt klar?

 

[Rallenaldo]

Also bedeutet das folgendes:

Für a=4:

System.out.println(a);     //3
if (a!=0) rekursion(a);     // Rekursion a wird wieder gestartet
System.out.println(a);     //3

Für a=3:

System.out.println(a);     //3 <-- Ausgabewert aus a=4
System.out.println(a);     //2 <-- Ausgabewert aus a=3
if (a!=0) rekursion(a);     // Rekursion a wird wieder gestartet
System.out.println(a);     //2 <-- Ausgabewert aus a=3
System.out.println(a);     //3 <-- Ausgabewert aus a=4

Für a= 2:

System.out.println(a);     //3 <-- Ausgabewert aus a=4
System.out.println(a);     //2 <-- Ausgabewert aus a=3
System.out.println(a);     //1 <-- Ausgabewert aus a=2
if (a!=0) rekursion(a);     // Rekursion a wird wieder gestartet
System.out.println(a);     //1 <-- Ausgabewert aus a=2
System.out.println(a);     //2 <-- Ausgabewert aus a=3
System.out.println(a);     //3 <-- Ausgabewert aus a=4

Für a= 1:

System.out.println(a);     //3 <-- Ausgabewert aus a=4
System.out.println(a);     //2 <-- Ausgabewert aus a=3
System.out.println(a);     //1 <-- Ausgabewert aus a=2
System.out.println(a);     //0 <-- Ausgabewert aus a=1
if (a!=0) rekursion(a);     // Rekursionsende
System.out.println(a);     //0 <-- Ausgabewert aus a=1
System.out.println(a);     //1 <-- Ausgabewert aus a=2
System.out.println(a);     //2 <-- Ausgabewert aus a=3
System.out.println(a);     //3 <-- Ausgabewert aus a=4

Er geht so zu sagen den kompletten Code durch, wenn a!= 0 ist und das jeweils erste Ergebnis ist "außen" und die nachfolgenden berechnungen werden "innen" ausgegeben.

 

[hüteüberhüte]

Muss natürlich wird statt werden heißen. Eine sich selbst aufrufende Methode bedeutet einfach nur, dass die vor dem rekursiven Aufruf stehenden Anweisungen zuerst ausgeführt werden, dann Nebeneffekte entstehen können (nicht ganz das korrekte Wort) und schließlich die danachstehenden Anweisungen ausgeführt werden.