imported>Innobello: Änderungen von 93.225.125.39 (Diskussion) auf die letzte Version von Aka zurückgesetzt

2024-12-03T12:27:28Z

Änderungen von 93.225.125.39 (Diskussion) auf die letzte Version von Aka zurückgesetzt

Neue Seite

Bei der '''rekursiven Programmierung''' ruft sich eine [[Prozedur (Programmierung)|Prozedur]], [[Funktion (Informatik)|Funktion]] oder [[Unterprogramm#Terminologie|Methode]] in einem [[Computerprogramm]] selbst wieder auf (d. h. enthält eine [[Rekursion]]). Auch der gegenseitige Aufruf stellt eine Rekursion dar.

Wichtig bei der [[Rekursion|rekursiven]] [[Programmierung]] ist eine [[Abbruchbedingung]] in dieser [[Funktion (Programmierung)|Funktion]], weil sich das rekursive [[Computerprogramm|Programm]] sonst theoretisch unendlich oft selbst aufrufen würde.

Rekursive [[Programmierung]] kann unter anderem in [[Prozedurale Programmierung|prozeduralen]] und [[Objektorientierte Programmierung|objektorientierten]] [[Programmiersprache]]n angewandt werden. Obwohl diese Sprachen in ihrem Sprachstandard die [[Rekursion]] ausdrücklich zulassen, stellen Selbstaufrufe und gegenseitige Aufrufe hier (aufgrund der verwendeten [[Programmierparadigma|Programmierparadigmen]]) jedoch eher die Ausnahme dar. Auch wenn in der Praxis zur Verbesserung des [[Programmierstil]]s auch hier durchaus häufig auf Rekursion zurückgegriffen wird, sind die meisten [[Funktion (Programmierung)|Funktionen]] in diesen Sprachen doch rein [[Iterative Programmierung|iterativ]].

In einigen Sprachen, wie z. B. in manchen [[funktionale Programmiersprache|funktionalen Programmiersprachen]] oder [[Makroprozessor]]en, muss die rekursive Programmiermethode zwingend verwendet werden, da [[Iterative Programmierung|iterative]] Sprachkonstrukte fehlen.

== Beispiele ==

=== Fakultät ===
Ein Beispiel für die Verwendung einer [[Rekursion|rekursiven]] [[Programmierung]] ist die Berechnung der [[Fakultät (Mathematik)|Fakultät]] einer Zahl. Die Fakultät ist das [[Produkt (Mathematik)|Produkt]] aller ganzen Zahlen von 1 bis zu dieser Zahl. Die Fakultät von 4 ist also <math>1 \cdot 2 \cdot 3 \cdot 4 = 24</math>.

Mathematiker definieren die Fakultät meistens so (eine rekursive Definition):

* Die Fakultät der Zahl 0 ist definitionsgemäß 1.
* Die Fakultät einer ganzen Zahl, die größer als Null ist, ist das Produkt dieser Zahl mit der Fakultät der nächstkleineren ganzen Zahl.

Die Definition funktioniert so:

:* Will man die '''Fakultät von 4''' berechnen, so muss man zunächst die Fakultät von 3 berechnen und das Ergebnis mit 4 multiplizieren.
::* Will man die Fakultät von 3 berechnen, so muss man zunächst die Fakultät von 2 berechnen und das Ergebnis mit 3 multiplizieren.
:::* Will man die Fakultät von 2 berechnen, so muss man zunächst die Fakultät von 1 berechnen und das Ergebnis mit 2 multiplizieren.
::::* Will man die Fakultät von 1 berechnen, so muss man zunächst die Fakultät von 0 berechnen und das Ergebnis mit 1 multiplizieren.
:::::* Die Fakultät von 0 ist nach Definition 1.
::::* Die Fakultät von 1 ist also 1*1=1
:::* Die Fakultät von 2 ist also 1*1*2=2
::* Die Fakultät von 3 ist also 1*1*2*3=6
:* Die Fakultät von 4 ist also 1*1*2*3*4=24

In einer [[Programmiersprache]] wie Pascal, die rekursive Programmierung zulässt, kann man die [[Fakultät (Mathematik)|Fakultät]] folgendermaßen eingeben:

Man definiert eine [[Funktion (Programmierung)|Funktion]] ''factorial'', die eine Zahl ''x'' als Eingabewert bekommt. Diese Funktion multipliziert ''x'' mit dem Rückgabewert von ''factorial(x - 1)'' außer bei ''x = 0'', dann liefert die Funktion das Ergebnis 1. Dies ist die Abbruchbedingung:

'''Rekursive Implementation der Fakultätsfunktion '''

<syntaxhighlight lang="pascal">
function factorial(x: Integer): Integer;
begin
if x = 0 then
factorial := 1
else
factorial := x * factorial(x - 1);
end;
</syntaxhighlight>

Mit der Startzahl ''x = 4'' würde der [[Computer]] rechnen:

4 * (3 * (2 * (1 * factorial(0))))

heraus kommt dann das richtige Ergebnis, nämlich 24.

=== Binäre Suche ===
Die [[binäre Suche]] in einem vorsortierten [[Feld (Datentyp)|Array]] lässt sich [[Rekursion|rekursiv]] [[Implementierung|implementieren]]. Wenn das mittlere Element kleiner als das gesuchte Element ist, wird die hintere Hälfte des Arrays rekursiv durchsucht. Wenn es größer als das gesuchte Element ist, wird die vordere Hälfte des Arrays rekursiv durchsucht. Ist es gleich dem gesuchten Element, ist die Suche beendet.

Die Abbruchbedingung für die [[Rekursion]] ist erfüllt, wenn das mittlere Element gleich dem gesuchten Element ist, die Suche also erfolgreich ist, oder wenn der Endindex kleiner als der Startindex ist, die Suche also erfolglos ist.

Die folgende [[Funktion (Programmierung)|Funktion]] ([[Methode (Programmierung)|Methode]]) für die [[Rekursion|rekursive]] [[binäre Suche]] ist in der [[Programmiersprache]] [[C-Sharp|C#]]:<syntaxhighlight lang="c#">
int RekursiveBinaereSuche(int[] werte, int gesuchterWert, int startIndex, int endIndex)
{
if (endIndex < startIndex)
{
// Wenn Element nicht gefunden, dann null zurückgeben
return null;
}
int mittlererIndex = (startIndex + endIndex) / 2;
if (werte[mittlererIndex] == gesuchterWert)
{
// Wenn Element gefunden, dann Index zurückgeben
return mittlererIndex;
}
else
{
if (werte[mittlererIndex] < gesuchterWert)
{
// Rekursiver Aufruf der Funktion für die hintere Hälfte
return RekursiveBinaereSuche(werte, gesuchterWert, mittlererIndex + 1, endIndex);
}
else
{
// Rekursiver Aufruf der Funktion für die vordere Hälfte
return RekursiveBinaereSuche(werte, gesuchterWert, startIndex, mittlererIndex - 1);
}
}
}
</syntaxhighlight>

== Effizienz ==

[[Rekursion|Rekursive]] [[Computerprogramm|Programme]] haben in der Regel keine gute [[Performance (Informatik)|Performance]]. Durch die wiederholten Funktionsaufrufe (Inkarnationen) wird immer wieder derselbe Methodeneintrittscode bearbeitet und bei jeder Inkarnation der [[Prozesskontext|Kontext]] gesichert, was zu zusätzlichem [[Programmcode]] und höherem [[Arbeitsspeicher]]verbrauch führt. Alle rekursiven [[Algorithmus|Algorithmen]] lassen sich jedoch auch durch [[iterative Programmierung]] implementieren und umgekehrt.

=== Fakultät ===
Man hätte die [[Fakultät (Mathematik)|Fakultät]] auch so [[Implementierung|implementieren]] können:

<syntaxhighlight lang="pascal">
function factorial(x: Integer): Integer;
var i, number: Integer;
begin
number := 1;

for i := 1 to x do
number := number * i;

factorial := number;
end;
</syntaxhighlight>
Hierbei gilt die Regel, dass für einfache Probleme eine [[Iterative Programmierung|iterative]] Implementierung häufig effizienter ist. So sollte z. B. auch die Fakultätsfunktion der Effizienz wegen in der Praxis iterativ implementiert werden. Bei komplizierten Problemstellungen (z. B. Aufgaben mit [[Baum (Graphentheorie)|Bäumen]]) hingegen lohnt sich oftmals der Einsatz einer rekursiven Lösung, da für solche Probleme eine iterative Formulierung schnell sehr unübersichtlich – und ineffizient – werden kann, da im schlimmsten Fall der [[Stapelspeicher|Stack]] durch den iterativen [[Algorithmus]] selbst verwaltet werden muss, was sonst der [[Prozessor]] direkt erledigt.

Nicht alle [[Höhere Programmiersprache|höheren Programmiersprachen]] lassen rekursive Aufrufe zu. Ein Beispiel dazu ist älteres [[Fortran]]. Ab Fortran 90 sind rekursive Aufrufe möglich. Andere [[Programmiersprache]]n sind dagegen grundsätzlich rekursiv (wie z. B. [[Prolog (Programmiersprache)|Prolog]]). Solche rekursiven Programmiersprachen und auch andere Sprachen wie z. B. [[Scheme]] setzen die [[Rekursion]] meistens effizient um.

== Implementierung ==
[[Rekursion]] wird in der Regel durch einen [[Stapelspeicher|Stack]] implementiert, der die Rücksprungadressen, aber auch alle lokalen Variablen und eventuell Funktionsergebnisse aufnimmt. Würde man, wie im obenstehenden Beispiel, die [[Fakultät (Mathematik)|Fakultät]] von 4 berechnen, so würde jeder Aufruf folgende Informationen auf den Stack legen:

#Platz für Ergebnis
#Argument ''x''
#Rücksprungadresse

Zunächst würde im Hauptprogramm also ''fac(4)'' aufgerufen und damit die folgenden Informationen auf den [[Stapelspeicher|Stack]] gelegt:

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|}

Die Fakultätsfunktion prüft jetzt, ob das Argument 0 ist. Da dies nicht der Fall ist, wird ''4*fac(3)'' berechnet. Zunächst muss also ''fac'' mit dem Argument 3 aufgerufen werden:

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|}

Das Argument ist wieder ungleich 0, also geht’s weiter mit ''3*fac(2)''.

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 7
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 8
| bgcolor="#C0C0FF" align="center" | '''2''' (Argument)
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 9
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|}

Das Argument ist wieder ungleich 0, also''2*fac(1)''.

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 7
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 8
| bgcolor="#C0C0FF" align="center" | '''2''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 9
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 10
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 11
| bgcolor="#C0C0FF" align="center" | '''1''' (Argument)
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 12
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|}

Das Argument ist wieder ungleich 0, also''1*fac(0)''.

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 7
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 8
| bgcolor="#C0C0FF" align="center" | '''2''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 9
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 10
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 11
| bgcolor="#C0C0FF" align="center" | '''1''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 12
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 13
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 14
| bgcolor="#C0C0FF" align="center" | '''0''' (Argument)
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 15
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|}

Jetzt ist das Argument 0, das Ergebnis also 1. Wir holen die Rücksprungadresse und das Argument vom [[Stapelspeicher|Stack]] und schreiben die 1 in den dafür vorgesehenen Platz. Der [[Rücksprung]] führt in die Fakultätsfunktion zurück:

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 7
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 8
| bgcolor="#C0C0FF" align="center" | '''2''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 9
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 10
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 11
| bgcolor="#C0C0FF" align="center" | '''1''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 12
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 13
| bgcolor="#C0C0FF" align="center" | '''1''' (Ergebnis)
|}

Jetzt kann man das Ergebnis mit dem Argument multiplizieren (1*1). Das neue Ergebnis ist wieder 1. Die [[Rücksprungadresse]] und das Argument werden vom [[Stapelspeicher|Stack]] geholt und das neue Ergebnis in den dafür vorgesehenen Platz geschrieben. [[Rücksprung]] in die Fakultätsfunktion:

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 7
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 8
| bgcolor="#C0C0FF" align="center" | '''2''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 9
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 10
| bgcolor="#C0C0FF" align="center" | '''1''' (Ergebnis)
|}

Wiederum wird das Ergebnis mit dem Argument multipliziert (1*2). Zurück in die Fakultätsfunktion:

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
|
|
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 5
| bgcolor="#C0C0FF" align="center" | '''3''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 6
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse in die Fakultätsfunktion''
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 7
| bgcolor="#C0C0FF" align="center" | '''2''' (Ergebnis)
|}

Das Ergebnis wird mit dem Argument multipliziert (2*3). Zurück in die Fakultätsfunktion:

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | ''Platz für Ergebnis''
|-
|
|
| bgcolor="#C0e0FF" align="center" | 2
| bgcolor="#C0C0FF" align="center" | '''4''' (Argument)
|-
|
|
| bgcolor="#C0E0FF" align="center" | 3
| bgcolor="#C0C0FF" align="center" | ''Rücksprungadresse ins Hauptprogramm''
|-
| '''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 4
| bgcolor="#C0C0FF" align="center" | '''6''' (Ergebnis)
|}

Das Ergebnis wird mit dem Argument multipliziert (6*4). Zurück ins Hauptprogramm

{| border="0" cellpadding="3" bordercolor="#000000"
| '''Stapelanfang'''<br>'''Stapelzeiger'''
| <math>\rightarrow</math>
| bgcolor="#C0E0FF" align="center" | 1
| bgcolor="#C0C0FF" align="center" | '''24''' (Ergebnis)
|}

Das Hauptprogramm muss dann nur noch das Ergebnis ''24'' vom [[Stapelspeicher|Stack]] holen.

== Siehe auch ==
* [[Quicksort]]
* [[Endrekursion]]
* [[Programmierparadigma]]
* [[Entrekursivierung]]

== Weblinks ==
{{Wikibooks|Rekursive Labyrinthe}}

[[Kategorie:Programmierparadigma]]
[[Kategorie:Rekursion]]

Rekursive Programmierung - Versionsgeschichte

imported>Innobello: Änderungen von 93.225.125.39 (Diskussion) auf die letzte Version von Aka zurückgesetzt