[C] Lista elementi di posto dispari

[SpecialOne1992]

Il testo: Scrivere una funzione ricorsiva che data una lista concatenata di interi , restituisca una nuova lista costituita dagli elementi di posto dispari
il mio codice :

//ritorna lista con gli elementi di posto dispari
#include<stdio.h>
#include<stdlib.h>
struct elemento{
      int inf;
      struct elemento*next;
       };
struct elemento* disp_lista(struct elemento*,int);
struct elemento* crea_lista(int);

int main(void){
    struct elemento*testa,*primo_disp=NULL;
    int dim,i=1;
    printf("Inserisci gli elementi della lista\n");
    scanf("%d",&dim);
    testa=crea_lista(dim);
    primo_disp=disp_lista(testa,i);
    while(primo_disp!=NULL){
                            printf("%d",primo_disp->inf);
                            printf("->");
                            primo_disp=primo_disp->next;
                            }
    printf("NULL\n");
          

system("pause");
return 0;
}

struct elemento*crea_lista(int dim){
       struct elemento *testa,*curr,*aus;
       int i=0;
       testa=(struct elemento*)malloc(sizeof(struct elemento));
       printf("inserisci elemento %d\n",i+1);
       scanf("%d",&testa->inf);
       testa->next=NULL;
       curr=testa;
       for(i=1;i<dim;i++){
       aus=(struct elemento*)malloc(sizeof(struct elemento));
       printf("inserisci elemento %d\n",i+1);
       scanf("%d",&aus->inf); 
       curr->next=aus;
       curr=aus;
       aus->next=NULL;
       }
       return testa;
       }

struct elemento*disp_lista(struct elemento*curr,int i){
    struct elemento*aus=NULL,*primo=NULL;
    if(curr==NULL) return NULL;
       else{
            if(i%2!=0){
            aus=(struct elemento*)malloc(sizeof(struct elemento));
            aus=curr;
            aus->next=disp_lista(curr->next,i++);
            return aus;
            }
            else
            aus=disp_lista(curr->next,i++);
            }
            }

e giustamente l'errore : il problema è che nella funzione non incrementa la variabile i e nella condizione dell'else non entra di conseguenza

[Scara95]

++i inquanto il valore deve prima essere incrementato e poi passato alla funzione.
i++ prima lo passa e poi lo incrementa.

Comunque è più corretto e sensato scrivere i+1

[SpecialOne1992]

Originariamente inviato da Scara95
++i inquanto il valore deve prima essere incrementato e poi passato alla funzione.
i++ prima lo passa e poi lo incrementa.

Comunque è più corretto e sensato scrivere i+1

ok come dici tu mi entra nell'else ma mi da un errore di segmentazione uffa

[Scara95]

Probabilmente c'è qualche NULL non controllato...
Comunque queste 2 linee in sequenza non hanno senso:

aus=(struct elemento*)malloc(sizeof(struct elemento));
aus=curr;

Poi non sono sicuro che la tua logica sia corretta.
Ti basterebbe una variabile flag impostata a 1 o 0 cambi il valore ad ogni chiamata ricorsiva con !flag e hai un sacco di problemi in meno.

if(flag)
 return cur->next = disp(cur->next, !flag);//codice
else
 return disp(cur->next, !flag);

semplificato a

disp( struct elemento* cur) {
 return cur->next = disp(cur->next->next);
}

Mancano i controlli per i NULL e non ho verificato che sia corretto.

Inoltre mancano un po' di memory free...

[SpecialOne1992]

perché non hanno senso quelle due righe di codice?
poi scusami non ho capito come vorresti implementare il flag

[Scara95]

Comunque in C vedo più normale fare il tutto con un ciclo e se proprio proprio devi utilizzare una funzione ricorsiva cambierei la struttura della funzione per sfruttare la tail recursion (Vedi concetti di programmazione funzionale fold left e fold right)

Ciao

[SpecialOne1992]

purtroppo si richiede espressamente che sia ricorsiva

[Scara95]

Originariamente inviato da SpecialOne1992
perché non hanno senso quelle due righe di codice?

Assegni una nuova area di memoria (un indirizzo) e subito cambi questa area a quella di cur (al suo indirizzo per la precisione), non copii il contenuto di cur i aus, ma il suo indirizzo.

poi scusami non ho capito come vorresti implementare il flag

Gli elementi dispari tu intendevi dispari per posizione (almeno per quanto hai scritto), per cui saranno uno pari e uno dispari in successione (dipende ovviamente se intendi partire da 1 o da 0) quindi la chiamata:

disp_list(list, 1);

Farà avverare il primo if e chiamerà se stessa in ricorsione come

cur->next = disp_list(cur->next, !flag);

flag cambia da 1 a 0 per effetto del ! e nella seconda chiamata l'if risulterà falso e si richiamerà la funzione dinuovo con

disp_list(cur->next, !flag);

saltando un elemento ma cambiando flag da 0 a 1 (sarebbe un qualsiasi valore non 0 in realtà, ma puoi considerarlo 1) e così fino alla fine, ovviamente con i dovuti controlli...

Io vedo più pulita l'ultima possibilità, quella semplificata, poi vedi tu...

[Scara95]

L'ultima semplificata è di una riga (più una o due righe (fai anche 3) di controlli NULL) è la più semplice e completa, io sceglierei quella...

[SpecialOne1992]

ora prove se funziona grazie