Qual è la differenza tra "ricorsione" e "autoreferente"?

Il contesto dei due termini è generalmente diverso.

L'autoreferenzialità è nel contesto dei dati - hai un tipo di dati che contiene un riferimento a qualcosa dello stesso tipo.

Ricorsivo è nel contesto del codice - hai una funzione o una procedura che chiama se stessa.

Esempio:

def factorial(n):
if n == 1:
    return 1
else:
    return n * factorial(n-1)

Ecco una funzione ricorsiva (in C):

unsigned int fibonacci(unsigned int n)
{
    unsigned int result = 1;

    if (n > 1)
        result = fibonacci(n - 1) + fibonacci(n - 2);

    return result;
}

Queste due chiamate a fibonacci() all'interno della funzione fibonacci() sono chiamate ricorsive .

Ecco una struttura dati autoreferenziale :

struct ListNode {
    char *data;
    struct ListNode *next;
}

Il primo elemento, data , è solo un puntatore a una sorta di dati. Il secondo elemento, next , è un puntatore a un'altra struttura ListNode . Se hai due o più strutture ListNode , puoi impostare il puntatore next di uno sull'indirizzo di un altro, e così via, e poi hai una lista collegata . La struttura è autoreferenziale perché la definizione della struttura si riferisce a se stessa. Se vuoi diventare veramente pazzo, puoi farlo:

struct ListNode *node = malloc(sizeof(struct ListNode));
node->data = someString;
node->next = node;

Ora hai un diverso tipo di auto-riferimento - non è solo la definizione di struct ListNode che si riferisce a se stessa ... hai impostato il next puntatore di node per puntare a node stesso. Questa è una lista circolare circolare che contiene solo un elemento. Carino, ma non molto utile. Ne parlo perché è una sorta di auto-riferimento, ma non è quello che le persone solitamente intendono quando parlano di tipi di dati autoreferenziali.

Le ricusazioni, per lo più utili, dovrebbero terminare dopo un certo numero di procedure, nel senso che esiste un valore iniziale. a meno che tu non abbia una cattiva ricorsione che è inutile.

Le Self References, di per sé non sono esattamente ricorsioni, ma possono essere mostrate come ricorsive nel qual caso generalmente non terminano mai.

La ricorsione implica un'azione.

Esempi:

• una funzione che si chiama
• una regex che esegue una corrispondenza * o + (cioè ripetitiva)

Tecnicamente, la ricorsione dovrebbe avere uno stato di uscita ma non è un requisito.

L'auto-riferimento implica la struttura.

Ex. Un metodo di istanza che fa riferimento all'oggetto a cui è collegato.

La ricorsione richiede che qualcosa venga elaborato chiamando lo stesso processo (spesso con parametri diversi). Anche se usi spesso funzioni e queste funzioni si chiamano, tecnicamente entrano in un nuovo passaggio che sembra assomigliare al luogo da cui provengono.

Riferimento automatico significa che qualcosa si riferisce a se stesso. Le classi possono essere autoreferenziali utilizzando this , ma non è ricorsivo in modo significativo.