[c]linked list

[amok09]

ragazzi vorrei chiedervi gentilmente se riuscite a trovare il problema a questo mio programma. Lo descrivo brevemente.. si tratta di creare 3 liste che contengano rispettivamente tre polinomi P1, P2 e P3; e realizzare una funzione che sommi i primi due polinomi e restituisca il risultato nella lista P3. Il problema che riscontro è nella funzione somma (che sostanzialmente si tratta di un merge), dove il programma entra un unica volta nel primo while. Spero di esser stato abbastanza chiaro... mmm.. ecco il codice

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

typedef struct struttura{
        int coef;
        int esp;};
typedef struct linked_list{
        struttura polinomio;
        struct linked_list *next;}eq;
typedef eq *link;

void inserisci (struttura *nuovo);
void inserisciOrd (link *nodo, struttura nuovo);
void printlist (link nodo);
void somma (link nodo, link nodo_2, link *nodo_3);
void menu(void);

main()
{
      
      
      
      menu();
      
      
      
      printf("\n\t*** F I N E ***");
      system("PAUSE");
}

void menu()
{
     link P1=NULL, P2=NULL, P3=NULL;
      P3=(eq*)malloc(sizeof(eq));
     int scelta;
     struttura nuovo;
     printf("\n\t *** I S T R U Z I O N I ***\n\n");
     printf("1)Inserisci nuovo membro al primo polinomio;\n2)Stampa primo polinomio;\n3)Inserisci nuovo membro al secondo polinomio;\n4)Stampa secondo polinomio;\n5)Somma polinomi;\n6)Esci.\n\n");
     printf("?"); scanf("%d",&scelta);
     if (scelta<=0 || scelta >6)
      {
                   puts("Scelta sbagliata. <scelte possibili 1,2,3,4,5,6>");
                   printf("?"); scanf("%d",&scelta);
                   }
                   
     while (scelta<=5)
     {
            switch (scelta)
            {
                   case 1 : 
                        inserisci (&nuovo);
                        inserisciOrd (&P1, nuovo);
                        break;
                   case 2 :
                        printlist(P1);
                        break;
                   case 3:
                        inserisci (&nuovo);
                        inserisciOrd (&P2, nuovo);
                        break;
                   case 4 :
                        printlist(P2);
                        break;
                   case 5 :
                        somma (P1,P2,&P3);
                        printlist(P3);
                        break;
                   case 6:
                        return;
                        break;
                        }                       
                   
                      printf("\n?"); scanf("%d",&scelta); 
     }
     
}

void inserisci (struttura *nuovo)
{
     printf("coef = ");
     scanf("%d",&(nuovo->coef));
     printf("esp = ");
     scanf("%d", &(nuovo->esp));
     }

void inserisciOrd( link *nodo, struttura nuovo)
{
     link succ, prec, temp;
     temp=(eq*)malloc(sizeof(eq));
     temp->polinomio=nuovo;
     temp->next=NULL;
     
     prec=NULL;
     succ=*nodo;
     while(succ!=NULL && nuovo.esp>succ->polinomio.esp)
     {
                      prec=succ;
                      succ=succ->next;}
                      if (prec==NULL)
                      {
                                     temp->next=*nodo;
                                     *nodo=temp;}
                                     else{
                                          prec->next=temp;
                                          temp->next=succ;
                                          }
}

void printlist (link nodo)
{
     system("PAUSE");
     if (nodo==NULL)
     printf("Nessun polinomio è stato memorizzato\n\n");
     else{
          
          while(nodo!=NULL)
          {
                           system("PAUSE");
                           printf("%dx^%d ", nodo->polinomio.coef, nodo->polinomio.esp);
                           nodo=nodo->next;
                           system("PAUSE");
                           }
          }
}

void somma (link nodo, link nodo_2, link *nodo_3)
{
     
     
     *nodo_3=(eq*)malloc(sizeof(eq));
     
     while( (nodo !=NULL) && (nodo_2 != NULL))
     {
            if ( (nodo->polinomio.esp) == (nodo_2->polinomio.esp))
            {
                 
                 
                 ((*nodo_3)->polinomio.coef) = (nodo->polinomio.coef) + (nodo_2->polinomio.coef);
                                  
                 (*nodo_3)->polinomio.esp= nodo->polinomio.esp;
                 
                 nodo=nodo->next;
                 nodo_2=nodo_2->next;
                 
                 }
            else if ( (nodo->polinomio.esp) < (nodo_2->polinomio.esp))
            {
                     
                 ((*nodo_3)->polinomio.esp)=(nodo->polinomio.esp);
                 
                 ((*nodo_3)->polinomio.coef)=(nodo->polinomio.coef);
                
                 nodo=nodo->next;
            }
            else      {       
                                     ((*nodo_3)->polinomio.esp) = (nodo_2->polinomio.esp);
                                ((*nodo_3)->polinomio.coef) = (nodo_2->polinomio.coef);
                
                nodo_2=nodo_2->next;
            }
            
            (*nodo_3)=(*nodo_3)->next;
     }
     
     if (nodo==NULL)
     {
                    while(nodo_2 !=NULL)
                    {
                                 (*nodo_3)->polinomio.esp=nodo_2->polinomio.esp;
                                 (*nodo_3)->polinomio.coef=nodo_2->polinomio.coef;
                                 nodo_2=nodo_2->next;
                                 (*nodo_3)=(*nodo_3)->next;
                                 }
     } else    if (nodo_2==NULL)
     {
                      while(nodo!=NULL)
                      {
                                       (*nodo_3)->polinomio.esp=nodo->polinomio.esp;
                                       (*nodo_3)->polinomio.coef=nodo->polinomio.coef;
                                       nodo=nodo->next;
                                       (*nodo_3)=(*nodo_3)->next;
                      }
     }
     
 }   

}

[Massachusetts]

In che modo la funzione somma dovrebbe fare il merge delle 2 liste ? l'unico critrerio è il confronto delle variabili esp ? e nel caso una delle liste fosse più lunga dell'altra i suoi valori dovrebbero semplicemente essere appesi in coda ?
E perchè detta funzione somma non utilizza la funzione inserisciOrd per creare la terza lista ?
Insomma spiega meglio cosa deve fare il codice. Ancora meglio se posti la traccia.

[amok09]

La traccia è la seguente.
Si rappresenti un polinomio sotto forma di linked list, in cui ci sono tanti elementi quanti sono i termini che formano il polinomio. Ogni nodo della lista è costituito dal campo coef e dal campo esp. Scrivere un programma che, assegnati due qualsiasi polinomi P1 e P2, determini il polinomio P3 (rappresentato ancora da una linked list) dato dalla somma di P1 e P2. Il programma deve creare le liste che rappresentano i polinomi P1,P2, e P3 (in ordine crescente secondo l'esponente dei termini).

[amok09]

la funzione somma non utilizza inserisciOrd perchè i membri delle liste P1 e P2 in realtà già sono in ordine, e quindi la funzione li prende ordinatamente.

[Massachusetts]

Nella funzione somma tu allochi memoria per una terza lista, ma allochi memoria per un solo nodo e questo non va bene, è per questo che il programma crasha quando tenti di accedere a presunti elementi successivi, che però in pratica non esistono.
Sfruttando invece la già esistente funzione inserisciOrd, ti risparmi di scriverne un'altra quasi uguale. E secondo me poco importa se per la terza lista sarebbe superfluo l'ordinamento.

[amok09]

ma non ho capito in che modo posso usare inserisciOrd ad esempio nel caso siano uguali gli esponenti, assegno al campo coef la somma dei coefficienti e al campo esp l'esponente, come utilizzo la funzione inserisciOrd che invece ha come argomento oltre al nodo, una struttura?

[Massachusetts]

Originariamente inviato da amok09
ma non ho capito in che modo posso usare inserisciOrd ad esempio nel caso siano uguali gli esponenti, assegno al campo coef la somma dei coefficienti e al campo esp l'esponente, come utilizzo la funzione inserisciOrd che invece ha come argomento oltre al nodo, una struttura?

Che domande non è tuo il codice ?
Devo dirti io come usare una funzione che tu hai creato ? :rollo:

Una cosa del genere in ogni caso

void somma (link nodo, link nodo_2, link *nodo_3)
{
	struttura nuovo;
	while( (nodo !=NULL) && (nodo_2 != NULL))
	{
		if( nodo->polinomio.esp == nodo_2->polinomio.esp )
		{
			nuovo.coef = nodo->polinomio.coef + nodo_2->polinomio.coef;
			nuovo.esp  = nodo->polinomio.esp;
			nodo   = nodo->next;
			nodo_2 = nodo_2->next;
		}
		else if( nodo->polinomio.esp < nodo_2->polinomio.esp )
		{
			nuovo.esp  = nodo->polinomio.esp;
			nuovo.coef = nodo->polinomio.coef;
			nodo = nodo->next;
		}
		else
		{
			nuovo.esp  = nodo_2->polinomio.esp;
			nuovo.coef = nodo_2->polinomio.coef;
			nodo_2 = nodo_2->next;
		}
		inserisciOrd( nodo_3, nuovo);
	}
	....

[amok09]

scusa ma è il secondo programma che provo a fare, e non ho ancora dimestichezza con il linguaggio. Comunque grazie mille