[C++] Stampa ricorsiva di elementi in una lista di posizione pari

[Gianni91]

Ciao a tutti
Avrei delle domande su una funzione ricorsiva..

void stampa(Elem* L,int k=1){
     if(L==0)return;
     stampa(L->pun,k+1);
     if((k%2)==0)cout<<L->info<<endl;
     }

Questa soluzione di esercizio ,stampa gli elementi di una lista che sono in posizione pari..
Quello che non capisco di questo tipo di ricorsione è che prima fa la ricorsione fino a quando L==0??ma in qusto caso L non punta a niente..non dovrebbe essere almeno L->pun??
Poi come fa a stampare come fosse nella ricorsione,ma in realtà sta fuori??
Qualcuno può spiegarmi come funzionano questo tipo di ricorsioni NON in coda,anche linkandomi documentazione..
Grazie

[alukard990]

L==0 dovrebbe essere l'inizio della lista quindi si considera 0 come pari e si va all'elemento di posto 1...poi prima del return non dovresti fare una chiamata ricorsiva in cui passi l'elemento successivo della lista? credo che rimanga sempre bloccato all'elemento iniziale...e comunque se esiste una soluzione iterativa ovvia(come credo che nel tuo caso sia anche piuttosto banale)la ricorsione va evitata in quanto la applichi ad algoritmi che siano di loro stessa natura ricorsivi e quando le prestazioni del sistema sono un punto dolente

[Gianni91]

Per quello che so io L==NULL significa che non punta a niente.
Per quanto riguarda il codice funziona xchè l'ho testato e tra l'altro é una soluzione del compito del mio prof,che ha espressamete richiesto una funzione ricorsiva..

[ramy89]

Originariamente inviato da alukard990
L==0 dovrebbe essere l'inizio della lista quindi si considera 0 come pari e si va all'elemento di posto 1...poi prima del return non dovresti fare una chiamata ricorsiva in cui passi l'elemento successivo della lista? credo che rimanga sempre bloccato all'elemento iniziale...e comunque se esiste una soluzione iterativa ovvia(come credo che nel tuo caso sia anche piuttosto banale)la ricorsione va evitata in quanto la applichi ad algoritmi che siano di loro stessa natura ricorsivi e quando le prestazioni del sistema sono un punto dolente

No, L==0 è stato inserito al posto L==NULL (che è equivalente), perchè la lista finisce quando si incontra un puntatore a NULL.
L è un puntatore, non un intero.Non si controlla se l' indirizzo contenuto in L è pari, si controlla k.
Un' evidente errore di sintassi è questo:

void stampa(Elem* L,int k=1) // sbagliato
void stampa(Elem *m, int k)

Non puoi fare un assegnamento nella dichiarazione dei parametri della funzione.
Un' altra cosa che noto è che la chiamata ricorsiva avviene prima di stampare i valori se k è pari, per cui stamperà i valori all' incontrario.
Ad esempio hai {10,15,17,29} nella lista, 10 e 17 sono in posizione pari.
Chiami stampa(L,0), che a sua volta chiama stampa(L,1) che chiama stampa(L,2), che chiama stampa(L,3) che chiama stampa(L,4).In stampa(L,4) L==NULL per cui si torna alla stampa(L,3), dove l' elemento non è pari per cui non viene stampato.Si torna alla stampa(L,2) e stampa 17, in stampa(L,1) k è dispari per cui non viene stampato, mentre in stampa(L,0) k è pari per cui viene stampato 10, ma se li vuoi stampare in ordine devi invertire le istruzioni: prima la stampa e poi la chiamata ricorsiva.

[Gianni91]

Originariamente inviato da ramy89
void stampa(Elem* L,int k=1) // sbagliato
void stampa(Elem *m, int k)

Guarda l'ho sempre fatto e visto fare,infatti io passo dal chiamante solo il puntatore di testa della lista,quello é un valore di default che assegno...
magari mi sto confondendo,ma sapevo che questo risolveva il problema nel caso in cui avessi..

int main(){
//
stampa(testa);
return 0;
}

Originariamente inviato da ramy89
Un' altra cosa che noto è che la chiamata ricorsiva avviene prima di stampare i valori se k è pari, per cui stamperà i valori all' incontrario.

ehm scusa ,non l'ho specificato prima,la funzione, infatti deve stampare al contrario,ed era proprio quel comportmento che volevo capire,ma come mai la stampa si comporta come una iterazione con una sola istruzione cout<<L->info<<endl;??..

[ramy89]

Originariamente inviato da Gianni91
Guarda l'ho sempre fatto e visto fare,infatti io passo dal chiamante solo il puntatore di testa della lista,quello é un valore di default che assegno...
magari mi sto confondendo,ma sapevo che questo risolveva il problema nel caso in cui avessi..

Ma questa:

void stampa(Elem* L,int k=1){
     if(L==0)return;
     stampa(L->pun,k+1);
     if((k%2)==0)cout<<L->info<<endl;
     }

E' una dichiarazione di funzione, non una chiamata a funzione.Prova a scrivere una funzione così e a compilarla, ti da errore.

originariamente inviato da Gianni91
ehm scusa ,non l'ho specificato prima,la funzione, infatti deve stampare al contrario,ed era proprio quel comportmento che volevo capire,ma come mai la stampa si comporta come una iterazione con una sola istruzione cout<<L->info<<endl;??..

Originariamente inviato da ramy89
Ad esempio hai {10,15,17,29} nella lista, 10 e 17 sono in posizione pari.
Chiami stampa(L,0), che a sua volta chiama stampa(L,1) che chiama stampa(L,2), che chiama stampa(L,3) che chiama stampa(L,4).In stampa(L,4) L==NULL per cui si torna alla stampa(L,3), dove l' elemento non è pari per cui non viene stampato.Si torna alla stampa(L,2) e stampa 17, in stampa(L,1) k è dispari per cui non viene stampato, mentre in stampa(L,0) k è pari per cui viene stampato 10, ma se li vuoi stampare in ordine devi invertire le istruzioni: prima la stampa e poi la chiamata ricorsiva.

[Gianni91]

Originariamente inviato da ramy89
Ma questa:

void stampa(Elem* L,int k=1){
     if(L==0)return;
     stampa(L->pun,k+1);
     if((k%2)==0)cout<<L->info<<endl;
     }

E' una dichiarazione di funzione, non una chiamata a funzione.Prova a scrivere una funzione così e a compilarla, ti da errore.

si certo infatti la chiamata a quella funzione l'ho messa nel main..
La funzione non mi da errore,quando compilo..
Riguardo il resto come é possibile che si comporti in questo modo??
(chiaramente si deve comportare cosi)
Questo avviene anche con ricorsioni in testa che non siano liste??

[ramy89]

Originariamente inviato da Gianni91
si certo infatti la chiamata a quella funzione l'ho messa nel main..
La funzione non mi da errore,quando compilo..

Comunque non è quello che hai postato qua.

Riguardo il resto come é possibile che si comporti in questo modo??
(chiaramente si deve comportare cosi)
Questo avviene anche con ricorsioni in testa che non siano liste??

Non capisco cosa intendi con "ricorsioni in testa che non siano liste".
Ogni elemento Elem ha anche l' elemento successivo, che è L->pun,se tu gli passi un qualcosa di diverso da un puntatore a Elem ti da errore, per cui tutti gli elementi avranno L->pos, che poi possa essere NULL è un altro discorso.
Puoi capire come funziona la ricorsione in questo caso da questa istruzione:

stampa(L->pun,k+1);

Questo dice tutto: stai chiamando di nuovo la funzione stampa passandogli l' elemento successivo, che è L->pun, per cui tutto il corpo della funzione viene rieseguito.

[Gianni91]

Originariamente inviato da ramy89
Comunque non è quello che hai postato qua.



Non capisco cosa intendi con "ricorsioni in testa che non siano liste".
Ogni elemento Elem ha anche l' elemento successivo, che è L->pun,se tu gli passi un qualcosa di diverso da un puntatore a Elem ti da errore, per cui tutti gli elementi avranno L->pos, che poi possa essere NULL è un altro discorso.
Puoi capire come funziona la ricorsione in questo caso da questa istruzione:

stampa(L->pun,k+1);

Questo dice tutto: stai chiamando di nuovo la funzione stampa passandogli l' elemento successivo, che è L->pun, per cui tutto il corpo della funzione viene rieseguito.

Intendevo funzioni per la stampa di figura tramite asterisco per esempio ,funzioni che non hanno nulla a che fare con le liste..

[ramy89]

Non capisco cosa dici