Newsgroup: it.comp.lang.c++
Titolo: Ricorsione (parte prima)

Salve a tutti,
mi sto impegolando nel labirinto della ricorsione e mi chiedevo se qualcuno 
di voi conoscesse un sito con qlc esempio commentato... in particolare mi 
servirebbe per un'esercitazione la stampa di un array con una funzione 
ricorsiva.
                                                                Grazie a 
tutti,
                                                                Cloud Strife 

 ricorsiva.
Tipicamente una funzione ricorsiva si rappresenta facendo riferimento alla
funzione fattoriale. Il fattoriale di un numero intero positivo n e' 1 * 2 *
3 * .. * n e si indica con n!. Si nota che n! = n * (n-1)! ovvero il
fattoriale di un numero e' il prodotto tra il numero e il fattoriale del suo
precedente. In C++ si puo' rappresentare come segue:
int fattoriale (int n) {
    if (n == 0)
        return 1;
    else
        return n *  fattoriale (n - 1);
};
Poiche' il fattoriale di 0 e' per definizione 1, la funzione si comporta
come segue:
Se n e' 0 restuisce 1 ed esce (in questo caso n == 0 e' la condizione di
fermata, necessaria per terminare la funzione) se invece n e' > 0 allora la
funzione ritorna il prodotto tra n e la funzione calcolata per n - 1. Ne
segue che il risultato finale sara: n * n-1 * n-2 ... n-n. Ma n-n == 0
quindi si verifica la condizione di fermata e la funzione termina.
In questo caso la funzione accetta anche n < 0 (servirebbe un controllo se
proprio si vuole evitare questo caso, magari facendo ritornare -1 per n < 0)
ma la condizione di fermata non si verificherebbe mai e la funzione non
terminerebbe finche' non si esaurisce la memoria.
Ciao

 Ciao
Ciao a te...
Cloud Strife

 che ho citato della stampa di un array....
Beh, normalmente non useresti una funzione ricorsiva per stampare un
array, ma, dovendo, potresti fare una cosa del genere:
se l'array ha un solo elemento, lo stampi ed esci.
se l'array ha n elementi, con n>1, richiami la stessa funzione con i
primi n-1 elementi dell'array e poi stampi l'ultimo.
(non  scrivo il codice perche' l'esercizio devi farlo tu, ma questo
suggerimento dovrebbe essere sufficiente)
Saluti,
Fabio

 che ho citato della stampa di un array....
Tipo questo?
#include <iostream>
void StampaArray(int* A, int size, int indice = 0) {
 if (indice < size) {
  std::cout << A[indice] << std::endl;
  StampaArray(A, 10, indice + 1);
 };
};
int Array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int main() {
 StampaArray(Array, 10);
 return 0;
}
Ciao

 stampa di un array con una funzione ricorsiva.
#include <iostream>
void stampa(int i[], int inizio, int fine) {
        std::cout<<i[inizio]<<std::endl;
        if (inizio<fine)
                stampa(i, inizio+1, fine);
}
int main() {
        int i[3]={3, 12, 35};
        stampa(i, 0, 2);
}
-- 
28/2/2005 | -1 all' alba!

 }
Grazie tantissime raga, volevo solo farvi una (spero) ultima domanda. Quando 
mi hanno spiegato la ricorsione hanno detto che il ragionamento che c'e' 
dietro deriva direttamente da una forma mentis presa da un principio 
matematico detto di induzione. Applicato alla ricorsione tale principio 
prevede un caso base e un passo induttivo, e dunque cosi' come per il 
fattoriale gentilmente postato da noixe (dove ho solo aggiunto i 2 commenti)
int fattoriale (int n) {
    if (n == 0)
        return 1;        //caso base
    else
        return n *  fattoriale (n - 1);        //passo induttivo
};
sia per quanto riguarda la serie di fibonacci e il massimo comun divisore, 
mi sono trovato a risolvere problemi ricorsivi suddividento il problema il 
questi due passi successivi, caso base e passo ricorsivo appunto. Nelle 
soluzione che gentilmente mi avete proposto non sono riuscito ad individuare 
un caso base ma soltanto il passo ricorsivo e mi chiedevo come mai e se 
l'algoritmo puo' essere condotto alla forma concettuale che ho appena 
esposto...magari sto dicendo fesserie peche' per la specifica del problema 
cio' non e' previsto ma chiedo comunque chiarimenti in proposito.
Ancora grazie
Cloud Strife ^_^

 che ho appena esposto...
il fatto che sia un po' diversa da come e' stata mostrata e' dato dal
fatto che la funzione stampa, per come e' stata concepita, non ritorna
valore, ma lavora su monitor.
una versione piu' "chiara" induttivamente, dal tuo punto di vista potrebbe
essere:
void stampa (int i[], int inizio, int fine) {
        if (inizio==fine)
                std::cout<<i[inizio]<<std::endl; //passo base
        else {
                std::cout<<i[inizio]<<std::endl; //passi induttivi
                stampa(i, inizio+1, fine);
        }
}
cioe'
se devo stampare l' ultimo elemento //passo base
  stampo l' elemento e basta
altrimenti                          //passo induttivo
  stampa l' elemento e chiama la funzione per stampare il successivo
