[c] problema liste concatenate

[*MATRIX*]

ciao ragazzi

ho il seguente problema

date due liste L1 ed L2 devo fonderle in un unica lista L3 con una funzione RICORSIVA

devo copiare il primo elementto di L1 in L3 , il primo elemento di L2 nel secondo di L3 poi il secondo di L1 nel terxo di L3 ed il secondo di L2 nel quarto di L3e così via

esempio
L1 = 1 3 5 6 7
L2 = 2 4 6 8

L3= 1 2 3 4 5 6 7 8

le due liste hanno lunghezza diverse

per ora ho fatto questo codice ma non va dove sbaglio ?

il codice mi va in loop :cry: :cry: :cry:


struct elemento *FUSIONE(struct elemento *L1,struct elemento *L2,
struct elemento *testa)
{
struct elemento *app;
if ((L1!=NULL)||(L2!=NULL))
{
if (testa==NULL)
{
testa=(struct elemento *)malloc(sizeof (struct elemento));
app=testa;
}
else
if (L1!=NULL)
{
app->inf=L1->inf;
app=app->next;
app=(struct elemento *)malloc(sizeof (struct elemento));
if (L2!=NULL)
{
app->inf=L2->inf;
app=app->next;
app=(struct elemento *)malloc(sizeof (struct elemento));
}
return FUSIONE(L1->next,L2->next,app);
}
else
{
app->inf=L2->inf;
return FUSIONE(NULL,L2->next,app);
}
}
else
{
app=NULL;
return testa;
}
}

[xxNeoxx]

Scusa ma non ho capito bene una cosa....

al termine di tutta la procedura...le liste L1 ed L2 devono sparire dalla memoria??? e rimane solo L3...oppure vuoi creare una lista L3 mantenendo comumque L1 ed L2?

[*MATRIX*]

le liste L1 e L2 devono restare , sostanzialmente deve essere una copia dei valori delle due liste in in L3 ma RICORSIVAMENTE

ti prego dammi una mano :cry:

[Kenger]

A parte che non mi è molto chiara la struttura della tua chiamata ma direi che come l'hai fatta te (a parte andarti in loop infinito, che ammetto di non aver cercato) ti ritorna una lista con tutta la lista 1 e poi tutta la lista 2, che non è quello che ti serve, o no?

EDIT: Guardando meglio aggiungo anche che dovresti cercare di eliminare il parametro testa, la lista dovresti crearla sfruttando i valori di ritorno della ricorsione, non così.

PS: Ti va in loop infinito perchè non entra mai in L2, l'ultimo
return FUSIONE(NULL,L2->next,app);
deve diventare
return FUSIONE(L2->next,NULL,app);

[xxNeoxx]

sbagli nella gestione dei puntatori....è da un po che non programmo in C/C++ comunque deve fare attenzione al campo next dell'elemento aggiunto, inoltre per le funzioni ricorsive, conviene usare il puntatore originario di L3 per evitare sovraccarico della memoria e errori di ritorno...

ora ti posto una versione funzionante di quello che volevi fare...così capisci dove sbagli...
#include <stdio.h>
#include <stdlib.h>




struct el
{
int inf;
struct el* next;
};

void crea_lista(struct el**);
void show_lista(struct el*);
void fusione(struct el*, struct el*, struct el**);

int main()
{
struct el* L1=NULL;
struct el* L2=NULL;
struct el* L3=NULL;

printf("inserire i dati per la prima lista:\n");
crea_lista(&L1);
printf("\n\ninserire i dati per la seconda lista:\n");
crea_lista(&L2);

printf("\n\necco la prima lista: ");
show_lista(L1);

printf("\n\necco la seconda lista: ");
show_lista(L2);

printf("\n\necco la lista unita: ");
fusione(L1,L2,(&L3));
show_lista(L3);

printf("\n\necco la prima lista: ");
show_lista(L1);

printf("\n\necco la seconda lista: ");
show_lista(L2);
printf("\n\n");

return 0;
}

void crea_lista(struct el** L1)
{
int i,n;
struct el* app;
printf("quanti elementi vuoi caricare?: ");
scanf("%d",&n);
for (i=0;i<n;i++)
{
if(*L1==NULL)
{
app=(struct el*)malloc(sizeof(struct el));
printf("\ninserire il %d valore: ",i+1);
scanf("%d",&app->inf);
app->next=NULL;
*L1=app;
}else
{
app=*L1;
while(app->next!=NULL)
app=app->next;
app->next=(struct el*)malloc(sizeof(struct el));
printf("inserire il %d valore: ",i+1);
scanf("%d",&app->next->inf);
app->next->next=NULL;
}
}
}

void show_lista(struct el *L1)
{
while(L1!= NULL)
{
printf("%d ",L1->inf);
L1=L1->next;
}
}

void fusione(struct el* L1, struct el* L2, struct el** L3)
{
struct el* p;
struct el* q;
struct el* app;

if ((L1!=NULL)||(L2!=NULL))
{
if(L1!=NULL)
{
if((*L3)==NULL)
{
app=(struct el*)malloc(sizeof(struct el));
app->inf=L1->inf;
app->next=NULL;
*L3=app;
L1=L1->next;
if(L2!=NULL)
{
q=(struct el*)malloc(sizeof(struct el));
q->inf=L2->inf;
q->next=NULL;
app->next=q;
L2=L2->next;
}
}else
{
p=*L3;
while(p->next!=NULL)
p=p->next;
q=(struct el*)malloc(sizeof(struct el));
q->inf=L1->inf;
q->next=NULL;
p->next=q;
L1=L1->next;
if(L2!=NULL)
{
q=(struct el*)malloc(sizeof(struct el));
q->inf=L2->inf;
q->next=NULL;
p->next->next=q;
L2=L2->next;
}
}
}else if(L2!=NULL)
{
if(*L3==NULL)
{
app=(struct el*)malloc(sizeof(struct el));
app->inf=L2->inf;
app->next=NULL;
L2=L2->next;
*L3=app;
}else {
p=*L3;
while(p->next!=NULL)
p=p->next;
q=(struct el*)malloc(sizeof(struct el));
q->inf=L2->inf;
q->next=NULL;
p->next=q;
L2=L2->next;
}
}
fusione(L1,L2,&(*L3));
}
}


per qualsiasi cosa chiedi pure....