rekursive Lösung zum Potenzieren einer Zahl

[Miasto71]

Hallo Leute,

ich habe eine Frage zu einem Quellcode..und zwar wird im folgenden Code eine beliebige Zahl a mit b potenziert.

public static long potenzieren(int a, int b){
if(b==0){
return 1;
}

else{
return(potenzieren(a,b-1)*a);
}


Z.B wird 10 mit 3 potenziert, dass Ergebniss ist ja dann 1000;

wie genau bearbeitet das Programm diesen Code ab?

den IF-Zweig habe ich verstanden wenn b am Anfang der Initialisierung 0 ist wird einfach eine 1 ausgegeben

aber wie geht es weiter?

soll man in dem Else-Zweig wie folgt nachgehen 10*10, (3-1)*10 usw.;


könnte mir einer den Else Zweig dieses Codes erklären?


Ich danke im voraus

 

[sheel]

Hi

Das mit dem if...return 1 ist deswegen in Ordnung, weil es eine mathematische Regel ist.
Hat mit der Programmiersprache etc eigentlich überhaupt nichts zu tun, das wird auch auf dem Papier so gerechnet.
x hoch 0 ist immer 1.
Deshalb: Wenn der Exponent (hier die Variable b) 0 ist, wird einfach 1 zurückgegeben, ohne viel herumzurechnen.

Zum Ablauf:
Angenommen, es soll 8 hoch 2 berechnet werden: potenzieren(8,2)

-startet die erste Instanz der Funktion mit a=8 und b=2
-b ist nicht 0, also wird beim else weitergemacht
-Jetzt wird bei den Klammern von innen nach außen gearbeitet
-dh bei "return(potenzieren(a,b-1)*a);" kommt zuerst "b-1" dran
-b ist 2, "b-1" also 1; ergibt return(potenzieren(a,1)*a);
-a noch einsetzen: "return(potenzieren(8,1)*a);

Jetzt wird potenzieren mit a=8 und b=1 aufgerufen
Ergibt die zweite Instanz der Funktion; die wird wieder ganz normal komplett abgearbeitet
Die erste Ausgabe vom Ganzen, die ja jetzt eine zweite startet, wartet bis die zweite fertig ist.

--Dh die zweite Instanz der Funktion mit a=8 und b=1 wird gestartet
--b ist nicht 0, also wird beim else weitergemacht
--"return(potenzieren(a,b-1)*a);"
--b ist 1, "b-1" also 0; ergibt return(potenzieren(a,0)*a);
--a noch einsetzen: "return(potenzieren(8,0)*a);
--jetzt startet die zweite Instanz noch eine Dritte mit a=8 und b=0 und wartet wiederrum, bis die fertig ist
---Die dritte Instanz der Funktion mit a=8 und b=0 ist gestartet
---Weil b 0 ist, wird beim if jetzt 1 zurückgegeben
---Instanz 3 ist damit fertig und die Zweite kann weitermachen
--Die Zweite wartet mit "return(potenzieren(8,0)*a);"
--"potenzieren(8,0)" hat 1 zurückgegeben, also ist es jetzt "return(1*a);
--ergibt "return(1*8);" ist "return(8);" und damit fertig, 8 wird zurückgegeben
-Jetzt kann die Erste Instanz weiterarbeiten, hat 8 zurückgekommen
-also wird aus "return(potenzieren(8,1)*a);" -> "return(8*a);" -> "return(8*8);" -> "return(64);"
-Fertig, 64 wird zurückgegeben
-Alles fertig

 

[Miasto71]

Hi Sheel,

vielen Dank für deine ausführliche Erklärung habe es jetzt teilweise verstanden,

könntest du dein Beispiel mal mit einem Parameter von z.B. 8 und 3 berechnen.

Wie sieht es dann mit der Berechnung aus

Hier hast du ja mit (8,1)gerechnet :

"also wird aus "return(potenzieren(8,1)*a);" -> "return(8*a);" -> "return(8*8);" -> "return(64);"
-Fertig, 64 wird zurückgegeben"

was wäre wenn in der funktion (potenzieren(8,2)*a) stehen würde, wie sollte man dann vorgehen ****?

danke im voraus

 

[sheel]

Nein, nicht 8/1, ich hab mit 8 und 2 angefangen

Nocheinmal verkürzt das Ganze:
Du rufst die Funktion mit 8/2 auf
-damit ist sie das erste mal gestartet mit 8/2
-b ist nicht 0, also wird die Funktion wieder mit 8 und 1 gestartet (b-1=2-1=1)
--Der zweite Start: 8/1, b ist wieder nicht 0, also:
---Wird noch ein drittes Mal gestartet mit 8/0 (b-1=1-1=0)
---b ist jetzt 0, also wird 1 zurückgegeben, fertig
--Zweiter Durchgang kann jetzt weitermachen
--Der multipliziert das zurückgegebene noch mit a, dh 1*a=1*8=8 und gibt 8 selber zurück, fertig
-Erster (Ursprünglicher) Durchgang macht weiter, Returnwert*a=8*8=64, gibt 64 zurück
Die gesamte rekurive potenzieren-Funktion ist jetzt Fertig, 8 hoch 2 hat 64 ergeben

Wenn du jetzt die Funktion statt mit 8/2 mit 8 und 3 aufrufst:
-b ist nicht 0
-potenzieren mit a und b-1 wird gestartet, ist potenzieren(8,2)
--potenzieren(8,2) ist genau das oben beschriebene, gibt 64 zurück
-Der 8/3-Durchgang multipliziert noch a dazu, 64*8=512 und gibt das zurück

Wenn du jetzt die Funktion mit 8 und 34 aufrufst:
-b ist nicht 0
-potenzieren mit a und b-1 wird gestartet, ist potenzieren(8,3)
--potenzieren(8,3) ist wiederrum oben beschrieben, gibt 512 zurück
-Der 8/4-Durchgang multipliziert noch a dazu, 512*8=4096 und gibt das zurück

usw...

 

[Miasto71]

danke für die Antowort,

ich habe es jetzt verstanden ich muss einfach darauf achten das die einzelnen Instanzen erstmal abgearbeitet werden.

thx