[C]Liste Circolari

[xbubbax]

Questo programma fonde in un'unica lista circolare, due liste circolari ordinate. Chiaramente la lista circolare risultante dovrà essere anch'essa ordinata.

Mi da un problema, cioè se ad esempio trova il primo numero della lista L1 minore o uguale del primo di L2 il primo numero di L2 verrà saltato e viceversa.
Non ho proprio idea di come correggere questo bug se cosi si puo chiamare

Help!

#include <stdio.h>
#include <stdlib.h>
#include "funzioni_liste_circolari.h"

listaPtr Ordinamento(listaPtr L1, listaPtr L2)
{
listaPtr L3=NULL;
listaPtr testa1=L1;
listaPtr testa2=L2;
listaPtr testa,curr,nuovo;

if(L1==NULL && L2==NULL){return NULL;}
if(L1==NULL){return L2;}
if(L2==NULL){return L1;}

if(L1->data<=L2->data)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L1->data;
nuovo->next=NULL;
testa=nuovo;
curr=nuovo;
L1=L1->next;
L2=L2->next;



}else
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L2->data;
nuovo->next=NULL;
testa=nuovo;
curr=nuovo;
L2=L2->next;
L1=L1->next;
}

while(L1!=testa1 && L2 !=testa2)
{
if(L1->data<=L2->data)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L1->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L1=L1->next;
}else
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L2->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L2=L2->next;
}
}

if(L1==testa1)
{
while(L2!=testa2)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L2->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L2=L2->next;
}
}


if(L2==testa2)
{
while(L1!=testa1)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L1->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L1=L1->next;
}
}


curr->next=testa;
return testa;
}

int main(void)
{
listaPtr L1=NULL;
listaPtr L2=NULL;
listaPtr L3=NULL;

L1=Crea(5);
printf("\n");
L2=Crea(5);
printf("\n");
L3=Ordinamento(L1,L2);
Stampa(L3);
}

[xbubbax]

ho risolto facendolo in un altro modo


#include <stdio.h>
#include <stdlib.h>
#include "funzioni_liste_circolari.h"

listaPtr Ordinamento(listaPtr L1, listaPtr L2)
{
listaPtr testa1=L1;
listaPtr testa2=L2;
listaPtr prev1,prev2;
listaPtr testa,nuovo,curr;

L1=L1->next;
L2=L2->next;

while(L1!=testa1)
{
prev1=L1;
L1=L1->next;
}
L1=testa1;

while(L2!=testa2)
{
prev2=L2;
L2=L2->next;
}
L2=testa2;

prev1->next=NULL;
prev2->next=NULL;

if(L1->data<=L2->data)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L1->data;
nuovo->next=NULL;
testa=nuovo;
curr=nuovo;
L1=L1->next;
}else
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L2->data;
nuovo->next=NULL;
testa=nuovo;
curr=nuovo;
L2=L2->next;
}

while(L1!=NULL && L2!=NULL)
{
if(L1->data<=L2->data)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L1->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L1=L1->next;
}else
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L2->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L2=L2->next;
}
}

if(L1==NULL)
{
while(L2!=NULL)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L2->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L2=L2->next;
}
}

if(L2==NULL)
{
while(L1!=NULL)
{
nuovo=(listaPtr)malloc(sizeof(nodo));
nuovo->data=L1->data;
curr->next=nuovo;
curr=nuovo;
curr->next=NULL;
L1=L1->next;
}
}

curr->next=testa;
return testa;
}





int main(void)
{
listaPtr L1=NULL;
listaPtr L2=NULL;
listaPtr L3=NULL;

L1=Crea(5);
printf("\n");
L2=Crea(5);
printf("\n");
L3=Ordinamento(L1,L2);
Stampa(L3);
}

[cionci]

Nota che hai scritto tante volte lo stessa identica sequenza di istruzioni...cosa ti fa pensare ?

[banryu79]

Nota che hai scritto tante volte lo stessa identica sequenza di istruzioni...cosa ti fa pensare ?

Need refactoring? :D

[cionci]

Need refactoring? :D
Sta urlando :D