Wie genau funktioniert die Schwanzrekursion?

Ich verstehe fast, wie die Schwanzrekursion funktioniert und welchen Unterschied sie zu einer normalen Rekursion hat. Ich verstehe nur nicht, warum es keinen Stapel erfordert, um sich seine Absenderadresse zu merken.

// tail recursion
int fac_times (int n, int acc) {
    if (n == 0) return acc;
    else return fac_times(n - 1, acc * n);
}

int factorial (int n) {
    return fac_times (n, 1);
}

// normal recursion
int factorial (int n) {
    if (n == 0) return 1;
    else return n * factorial(n - 1);
}

Es gibt nichts zu tun, nachdem eine Funktion selbst in einer Schwanzrekursionsfunktion aufgerufen wurde, aber es macht für mich keinen Sinn.

Der Compiler kann dies einfach transformieren

int fac_times (int n, int acc) {
    if (n == 0) return acc;
    else return fac_times(n - 1, acc * n);
}

in so etwas:

int fac_times (int n, int acc) {
label:
    if (n == 0) return acc;
    acc *= n--;
    goto label;
}

Sie fragen, warum "kein Stapel erforderlich ist, um sich an seine Absenderadresse zu erinnern".

Ich würde das gerne umdrehen. Es tut den Stapel verwenden , um die Absenderadresse zu erinnern. Der Trick besteht darin, dass die Funktion, in der die Schwanzrekursion auftritt, eine eigene Rücksprungadresse auf dem Stapel hat. Wenn sie zur aufgerufenen Funktion springt, wird diese als ihre eigene Rücksprungadresse behandelt.

Konkret ohne Tail-Call-Optimierung:

f: ...
   CALL g
   RET
g:
   ...
   RET

In diesem Fall gsieht der Stapel beim Aufruf folgendermaßen aus:

   SP ->  Return address of "g"
          Return address of "f"

Auf der anderen Seite mit Tail-Call-Optimierung:

f: ...
   JUMP g
g:
   ...
   RET

In diesem Fall gsieht der Stapel beim Aufruf folgendermaßen aus:

   SP ->  Return address of "f"

Wenn Sie gzurückkehren, wird es eindeutig an den Ort zurückkehren, von dem aus Sie fangerufen wurden.

BEARBEITEN : Im obigen Beispiel wird der Fall verwendet, in dem eine Funktion eine andere Funktion aufruft. Der Mechanismus ist identisch, wenn sich die Funktion selbst aufruft.

Die Schwanzrekursion kann normalerweise vom Compiler in eine Schleife umgewandelt werden, insbesondere wenn Akkumulatoren verwendet werden.

// tail recursion
int fac_times (int n, int acc = 1) {
    if (n == 0) return acc;
    else return fac_times(n - 1, acc * n);
}

würde zu so etwas kompilieren

// accumulator
int fac_times (int n) {
    int acc = 1;
    while (n > 0) {
        acc *= n;
        n -= 1;
    }
    return acc;
}

In einer rekursiven Funktion müssen zwei Elemente vorhanden sein:

1. Der rekursive Aufruf
2. Ein Ort, an dem die Rückgabewerte gezählt werden können.

Eine "reguläre" rekursive Funktion hält (2) im Stapelrahmen.

Die Rückgabewerte in der regulären rekursiven Funktion bestehen aus zwei Arten von Werten:

• Andere Rückgabewerte
• Ergebnis der eigenen Funktionsberechnung

Schauen wir uns Ihr Beispiel an:

int factorial (int n) {
    if (n == 0) return 1;
    else return n * factorial(n - 1);
}

Der Rahmen f (5) "speichert" beispielsweise das Ergebnis seiner eigenen Berechnung (5) und den Wert von f (4). Wenn ich Fakultät (5) aufrufe, kurz bevor die Stapelaufrufe zusammenbrechen, habe ich:

 [Stack_f(5): return 5 * [Stack_f(4): 4 * [Stack_f(3): 3 * ... [1[1]]

Beachten Sie, dass jeder Stapel neben den genannten Werten den gesamten Funktionsumfang speichert. Die Speichernutzung für eine rekursive Funktion f ist also O (x), wobei x die Anzahl der rekursiven Aufrufe ist, die ich ausführen muss. Wenn ich also 1 KB RAM benötige, um Fakultät (1) oder Fakultät (2) zu berechnen, brauche ich ~ 100 KB, um Fakultät (100) zu berechnen, und so weiter.

Eine rekursive Schwanzfunktion setzt (2) in ihre Argumente.

Bei einer Schwanzrekursion übergebe ich das Ergebnis der Teilberechnungen in jedem rekursiven Rahmen unter Verwendung von Parametern an den nächsten. Sehen wir uns unser faktorielles Beispiel Tail Recursive an:

int Fakultät (int n) {int Helfer (int num, int akkumuliert) {wenn num == 0 zurück akkumuliert sonst Rückgabehelfer (num - 1, akkumuliert * num)} Rückkehr Helfer (n, 1)
}

Schauen wir uns die Frames in Fakultät (4) an:

[Stack f(4, 5): Stack f(3, 20): [Stack f(2,60): [Stack f(1, 120): 120]]]]

Sehen Sie die Unterschiede? Bei "regulären" rekursiven Aufrufen setzen die Rückgabefunktionen den Endwert rekursiv zusammen. In der Schwanzrekursion verweisen sie nur auf den Basisfall (zuletzt ausgewertet) . Wir nennen Akkumulator das Argument, das die älteren Werte verfolgt.

Rekursionsvorlagen

Die reguläre rekursive Funktion lautet wie folgt:

type regular(n)
    base_case
    computation
    return (result of computation) combined with (regular(n towards base case))

Um es in eine Schwanzrekursion umzuwandeln, haben wir:

• Führen Sie eine Hilfsfunktion ein, die den Akku trägt
• Führen Sie die Hilfsfunktion innerhalb der Hauptfunktion aus, wobei der Akku auf den Basisfall eingestellt ist.

Aussehen:

type tail(n):
    type helper(n, accumulator):
        if n == base case
            return accumulator
        computation
        accumulator = computation combined with accumulator
        return helper(n towards base case, accumulator)
    helper(n, base case)

Sieh den Unterschied?

Tail Call-Optimierung

Da in den Non-Border-Cases der Tail Call-Stapel kein Status gespeichert ist, sind sie nicht so wichtig. Einige Sprachen / Dolmetscher ersetzen dann den alten Stapel durch den neuen. Da die Anzahl der Aufrufe nicht durch Stapelrahmen eingeschränkt wird, verhalten sich die Endaufrufe in diesen Fällen wie eine for-Schleife .

Es liegt an Ihrem Compiler, es zu optimieren, oder nein.

Hier ist ein einfaches Beispiel, das zeigt, wie rekursive Funktionen funktionieren:

long f (long n)
{

    if (n == 0) // have we reached the bottom of the ocean ?
        return 0;

    // code executed in the descendence

    return f(n-1) + 1; // recurrence

    // code executed in the ascendence

}

Endrekursion ist eine einfache rekursive Funktion, wo Wiederholung am Ende der Funktion erfolgt, so wird kein Code in ascendence getan, die meisten Compiler von High-Level - Programmiersprachen hilft zu tun , was bekanntlich Endrekursion Optimierung , hat auch eine komplexere Optimierung, bekannt als Tail-Rekursionsmodulo

Die rekursive Funktion ist eine Funktion, die von selbst aufruft

Es ermöglicht Programmierern, effiziente Programme mit einer minimalen Menge an Code zu schreiben .

Der Nachteil ist, dass sie Endlosschleifen und andere unerwartete Ergebnisse verursachen können, wenn sie nicht richtig geschrieben werden .

Ich werde sowohl die einfache rekursive Funktion als auch die Schwanzrekursive Funktion erklären

Um eine einfache rekursive Funktion zu schreiben

1. Der erste zu berücksichtigende Punkt ist, wann Sie sich entscheiden sollten, aus der Schleife herauszukommen, die die if-Schleife ist
2. Der zweite ist, was zu tun ist, wenn wir unsere eigene Funktion sind

Aus dem gegebenen Beispiel:

public static int fact(int n){
  if(n <=1)
     return 1;
  else 
     return n * fact(n-1);
}

Aus dem obigen Beispiel

if(n <=1)
     return 1;

Ist der entscheidende Faktor, wann die Schleife verlassen werden soll

else 
     return n * fact(n-1);

Ist die eigentliche Verarbeitung durchzuführen

Lassen Sie mich die Aufgabe einzeln aufteilen, um das Verständnis zu erleichtern.

Mal sehen, was intern passiert, wenn ich renne fact(4)

1. Einsetzen von n = 4

public static int fact(4){
  if(4 <=1)
     return 1;
  else 
     return 4 * fact(4-1);
}

IfDie Schleife schlägt fehl und geht zur elseSchleife, sodass sie zurückkehrt4 * fact(3)

2. Im Stapelspeicher haben wir 4 * fact(3)

   Einsetzen von n = 3

public static int fact(3){
  if(3 <=1)
     return 1;
  else 
     return 3 * fact(3-1);
}

IfDie Schleife schlägt fehl und geht zur elseSchleife

so kehrt es zurück 3 * fact(2)

Denken Sie daran, wir haben `` `4 * fact (3)` `genannt

Die Ausgabe für fact(3) = 3 * fact(2)

Soweit hat der Stack 4 * fact(3) = 4 * 3 * fact(2)

3. Im Stapelspeicher haben wir 4 * 3 * fact(2)

   Einsetzen von n = 2

public static int fact(2){
  if(2 <=1)
     return 1;
  else 
     return 2 * fact(2-1);
}

IfDie Schleife schlägt fehl und geht zur elseSchleife

so kehrt es zurück 2 * fact(1)

Denken Sie daran, wir haben angerufen 4 * 3 * fact(2)

Die Ausgabe für fact(2) = 2 * fact(1)

Soweit hat der Stack 4 * 3 * fact(2) = 4 * 3 * 2 * fact(1)

3. Im Stapelspeicher haben wir 4 * 3 * 2 * fact(1)

   Einsetzen von n = 1

public static int fact(1){
  if(1 <=1)
     return 1;
  else 
     return 1 * fact(1-1);
}

If Schleife ist wahr

so kehrt es zurück 1

Denken Sie daran, wir haben angerufen 4 * 3 * 2 * fact(1)

Die Ausgabe für fact(1) = 1

Soweit hat der Stack 4 * 3 * 2 * fact(1) = 4 * 3 * 2 * 1

Schließlich ist das Ergebnis von Tatsache (4) = 4 · 3 · 2 · 1 = 24

Die Schwanzrekursion wäre

public static int fact(x, running_total=1) {
    if (x==1) {
        return running_total;
    } else {
        return fact(x-1, running_total*x);
    }
}

1. Einsetzen von n = 4

public static int fact(4, running_total=1) {
    if (x==1) {
        return running_total;
    } else {
        return fact(4-1, running_total*4);
    }
}

IfDie Schleife schlägt fehl und geht zur elseSchleife, sodass sie zurückkehrtfact(3, 4)

2. Im Stapelspeicher haben wir fact(3, 4)

   Einsetzen von n = 3

public static int fact(3, running_total=4) {
    if (x==1) {
        return running_total;
    } else {
        return fact(3-1, 4*3);
    }
}

IfDie Schleife schlägt fehl und geht zur elseSchleife

so kehrt es zurück fact(2, 12)

2. Im Stapelspeicher haben wir fact(2, 12)

   Einsetzen von n = 2

public static int fact(2, running_total=12) {
    if (x==1) {
        return running_total;
    } else {
        return fact(2-1, 12*2);
    }
}

IfDie Schleife schlägt fehl und geht zur elseSchleife

so kehrt es zurück fact(1, 24)

3. Im Stapelspeicher haben wir fact(1, 24)

   Einsetzen von n = 1

public static int fact(1, running_total=24) {
    if (x==1) {
        return running_total;
    } else {
        return fact(1-1, 24*1);
    }
}

If Schleife ist wahr

so kehrt es zurück running_total

Die Ausgabe für running_total = 24

Schließlich ist das Ergebnis der Tatsache (4,1) = 24

Meine Antwort ist eher eine Vermutung, da Rekursion etwas mit der internen Implementierung zu tun hat.

Bei der Schwanzrekursion wird die rekursive Funktion am Ende derselben Funktion aufgerufen. Wahrscheinlich kann der Compiler wie folgt optimieren:

1. Lassen Sie die laufende Funktion auflaufen (dh der verwendete Stapel wird zurückgerufen)
2. Speichern Sie die Variablen, die als Argumente für die Funktion verwendet werden sollen, in einem temporären Speicher
3. Rufen Sie danach die Funktion mit dem vorübergehend gespeicherten Argument erneut auf

Wie Sie sehen können, wickeln wir die ursprüngliche Funktion vor der nächsten Iteration derselben Funktion ab, sodass wir den Stapel nicht wirklich "verwenden".

Ich glaube jedoch, dass diese Optimierung möglicherweise nicht angewendet wird, wenn innerhalb der Funktion Destruktoren aufgerufen werden müssen.

Der Compiler ist intelligent genug, um die Schwanzrekursion zu verstehen. Falls bei der Rückkehr von einem rekursiven Aufruf keine Operation ansteht und der rekursive Aufruf die letzte Anweisung ist, fallen Sie unter die Kategorie der Schwanzrekursion. Der Compiler führt im Wesentlichen eine Optimierung der Schwanzrekursion durch und entfernt die Stapelimplementierung. Berücksichtigen Sie den folgenden Code.

void tail(int i) {
    if(i<=0) return;
    else {
     system.out.print(i+"");
     tail(i-1);
    }
   }

Nach der Optimierung wird der obige Code in den folgenden Code konvertiert.

void tail(int i) {
    blockToJump:{
    if(i<=0) return;
    else {
     system.out.print(i+"");
     i=i-1;
     continue blockToJump;  //jump to the bolckToJump
    }
    }
   }

Auf diese Weise führt der Compiler die Optimierung der Schwanzrekursion durch.