Come funziona esattamente la ricorsione della coda?

Quasi capisco come funziona la ricorsione della coda e la differenza tra essa e una normale ricorsione. Ho solo non capisco il motivo per cui non necessita di stack a ricordare il suo indirizzo di ritorno.

// 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);
}

Non c'è niente da fare dopo aver chiamato una funzione stessa in una funzione di ricorsione in coda, ma per me non ha senso.

Il compilatore è semplicemente in grado di trasformarlo

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

in qualcosa di simile:

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

Chiedete perché "non richiede che lo stack ricordi il suo indirizzo di ritorno".

Vorrei cambiare questa situazione. Si fa utilizzare lo stack di ricordare l'indirizzo di ritorno. Il trucco è che la funzione in cui si verifica la ricorsione in coda ha il proprio indirizzo di ritorno nello stack e quando salta alla funzione chiamata, la tratterà come il proprio indirizzo di ritorno.

In concreto, senza ottimizzazione della chiamata di coda:

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

In questo caso, quando gviene chiamato, lo stack avrà il seguente aspetto:

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

D'altra parte, con l'ottimizzazione della chiamata di coda:

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

In questo caso, quando gviene chiamato, lo stack avrà il seguente aspetto:

   SP ->  Return address of "f"

Chiaramente, quando gritorna, tornerà nella posizione da cui è fstato chiamato.

EDIT : L'esempio sopra usa il caso in cui una funzione chiama un'altra funzione. Il meccanismo è identico quando la funzione chiama se stessa.

La ricorsione in coda può essere solitamente trasformata in un ciclo dal compilatore, specialmente quando vengono utilizzati accumulatori.

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

compilerebbe qualcosa come

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

Ci sono due elementi che devono essere presenti in una funzione ricorsiva:

1. La chiamata ricorsiva
2. Un posto per tenere il conto dei valori restituiti.

Una funzione ricorsiva "normale" mantiene (2) nello stack frame.

I valori restituiti nella normale funzione ricorsiva sono composti da due tipi di valori:

• Altri valori restituiti
• Risultato del calcolo della funzione propria

Diamo un'occhiata al tuo esempio:

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

Il frame f (5) "memorizza" il risultato del proprio calcolo (5) e il valore di f (4), per esempio. Se chiamo fattoriale (5), appena prima che le chiamate dello stack inizino a collassare, ho:

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

Si noti che ogni stack memorizza, oltre ai valori che ho menzionato, l'intero ambito della funzione. Quindi, l'utilizzo della memoria per una funzione ricorsiva f è O (x), dove x è il numero di chiamate ricorsive che devo fare. Quindi, se ho bisogno di 1kb di RAM per calcolare fattoriale (1) o fattoriale (2), ho bisogno di ~ 100k per calcolare il fattoriale (100) e così via.

Una funzione ricorsiva di coda inserisce (2) nei suoi argomenti.

In una ricorsione in coda, passo il risultato dei calcoli parziali in ogni frame ricorsivo a quello successivo utilizzando i parametri. Vediamo il nostro esempio fattoriale, Tail Recursive:

int fattoriale (int n) {int helper (int num, int accumulato) {if num == 0 return accumulato altrimenti return helper (num - 1, accumulato * num)} return helper (n, 1)
}

Diamo un'occhiata ai suoi frame nel fattoriale (4):

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

Vedi le differenze? Nelle chiamate ricorsive "regolari" le funzioni di ritorno compongono ricorsivamente il valore finale. In Tail Recursion fanno riferimento solo al caso base (l'ultimo valutato) . Chiamiamo accumulatore l'argomento che tiene traccia dei valori precedenti.

Modelli di ricorsione

La normale funzione ricorsiva va come segue:

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

Per trasformarlo in una ricorsione di coda noi:

• Introdurre una funzione di supporto che trasporta l'accumulatore
• eseguire la funzione di supporto all'interno della funzione principale, con l'accumulatore impostato sul case base.

Guarda:

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)

Vedi la differenza?

Ottimizzazione della chiamata di coda

Dal momento che nessuno stato viene memorizzato negli stack Non-Border-Case degli stack Tail Call, non sono così importanti. Alcune lingue / interpreti sostituiscono quindi il vecchio stack con quello nuovo. Quindi, senza stack frame che limitano il numero di chiamate, le Tail Calls si comportano proprio come un ciclo for in questi casi.

Spetta al tuo compilatore ottimizzarlo, o no.

Ecco un semplice esempio che mostra come funzionano le funzioni ricorsive:

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

}

La ricorsione in coda è una semplice funzione ricorsiva, in cui la ricorrenza viene eseguita alla fine della funzione, quindi nessun codice viene eseguito in ascesa, il che aiuta la maggior parte dei compilatori di linguaggi di programmazione di alto livello a fare ciò che è noto come Ottimizzazione della ricorsione della coda , ha anche un ottimizzazione più complessa nota come modulo di ricorsione della coda

La funzione ricorsiva è una funzione che chiama da sola

Consente ai programmatori di scrivere programmi efficienti utilizzando una quantità minima di codice .

Lo svantaggio è che possono causare loop infiniti e altri risultati imprevisti se non scritti correttamente .

Spiegherò sia la funzione ricorsiva semplice che la funzione ricorsiva di coda

Per scrivere una funzione ricorsiva semplice

1. Il primo punto da considerare è quando dovresti decidere di uscire dal ciclo che è il ciclo if
2. Il secondo è quale processo fare se siamo la nostra stessa funzione

Dall'esempio fornito:

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

Dall'esempio sopra

if(n <=1)
     return 1;

È il fattore decisivo quando uscire dal ciclo

else 
     return n * fact(n-1);

È l'effettiva elaborazione da eseguire

Consentitemi di interrompere il compito uno per uno per una facile comprensione.

Vediamo cosa succede internamente se corro fact(4)

1. Sostituendo n = 4

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

Ifil ciclo fallisce quindi va in elseciclo così ritorna4 * fact(3)

2. Nella memoria dello stack, abbiamo 4 * fact(3)

   Sostituendo n = 3

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

If il ciclo fallisce quindi va a elseciclo

quindi ritorna 3 * fact(2)

Ricorda che abbiamo chiamato `` 4 * fact (3) ``

L'output per fact(3) = 3 * fact(2)

Finora lo stack ha 4 * fact(3) = 4 * 3 * fact(2)

3. Nella memoria dello stack, abbiamo 4 * 3 * fact(2)

   Sostituendo n = 2

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

Ifil ciclo fallisce quindi va in elseciclo

quindi ritorna 2 * fact(1)

Ricorda che abbiamo chiamato 4 * 3 * fact(2)

L'output per fact(2) = 2 * fact(1)

Finora lo stack ha 4 * 3 * fact(2) = 4 * 3 * 2 * fact(1)

3. Nella memoria dello stack, abbiamo 4 * 3 * 2 * fact(1)

   Sostituendo n = 1

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

If loop è vero

quindi ritorna 1

Ricorda che abbiamo chiamato 4 * 3 * 2 * fact(1)

L'output per fact(1) = 1

Finora lo stack ha 4 * 3 * 2 * fact(1) = 4 * 3 * 2 * 1

Infine, il risultato di fatto (4) = 4 * 3 * 2 * 1 = 24

La ricorsione della coda sarebbe

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

1. Sostituendo n = 4

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

Ifil ciclo fallisce quindi va in elseciclo così ritornafact(3, 4)

2. Nella memoria dello stack, abbiamo fact(3, 4)

   Sostituendo n = 3

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

Ifil ciclo fallisce quindi va in elseciclo

quindi ritorna fact(2, 12)

2. Nella memoria dello stack, abbiamo fact(2, 12)

   Sostituendo n = 2

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

Ifil ciclo fallisce quindi va in elseciclo

quindi ritorna fact(1, 24)

3. Nella memoria dello stack, abbiamo fact(1, 24)

   Sostituendo n = 1

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

If loop è vero

quindi ritorna running_total

L'output per running_total = 24

Infine, il risultato di fatto (4,1) = 24

La mia risposta è più un'ipotesi, perché la ricorsione è qualcosa relativo all'implementazione interna.

Nella ricorsione in coda, la funzione ricorsiva viene chiamata alla fine della stessa funzione. Probabilmente il compilatore può ottimizzare nel modo seguente:

1. Lascia che la funzione in corso si concluda (cioè lo stack usato viene richiamato)
2. Memorizza le variabili che verranno utilizzate come argomenti della funzione in una memoria temporanea
3. Dopodiché, chiama di nuovo la funzione con l'argomento memorizzato temporaneamente

Come puoi vedere, stiamo terminando la funzione originale prima della successiva iterazione della stessa funzione, quindi non stiamo effettivamente "usando" lo stack.

Ma credo che se ci sono distruttori da chiamare all'interno della funzione, questa ottimizzazione potrebbe non essere applicabile.

Il compilatore è abbastanza intelligente da comprendere la ricorsione in coda. Nel caso in cui, durante il ritorno da una chiamata ricorsiva, non ci siano operazioni in sospeso e la chiamata ricorsiva è l'ultima istruzione, rientra nella categoria della ricorsione in coda. Il compilatore fondamentalmente esegue l'ottimizzazione della ricorsione in coda, rimuovendo l'implementazione dello stack.

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

Dopo aver eseguito l'ottimizzazione, il codice precedente viene convertito in uno inferiore.

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

Questo è il modo in cui il compilatore esegue l'ottimizzazione della ricorsione della coda.