[C] Secondo voi come soluzione è un delirio o ci può stare?

[D4rkAng3l]

WOW..l'esame di programmazione 1 è il 15 e non l'1...ho ancora 2 settimane per prepararmi (vi prego di sopportatmi ancora per un po').

Ho fatto questo esercizio...sicuramente c'è qualcosa che non và perchè sono stanco (infatti il compilatore dà qualche messaggino inquietante di troppo).
Ma visto che l'esame è su carta bada principalmente alla logica (poi nel caso domani mattina gli dò una sistemata e vedo cos'è che non và).
Secondo voi la mia soluzione ha senso o è un delirio dal punto di vista logico?

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

typedef struct Dat{
    long coD;
    char *descr;    // Stringa allocata dinamicamente
    struct Dat *next;
} Dat, *LDat;

/* La funzione LDat() riceve in ingresso il puntatore al primo nodo di una lista
   L ed in puntatore al primo nodo di una lista M.
   Modifica la lista L nel seguente modo: per ogni elemento d della lista M se
   d.coD è negativo elimina da L, se esiste, l'elemento con campo coD uguale a
   -d.coD. Se invece d.cod è positivo inserisce (se un elemento con lo stesso
   valore del campo coD non esiste in L) un nuovo elemento in L uguale a d.
   La funzione ritorna il puntatore alla lista modificata (che può essere NULL).
   Le modifiche indotte dagli elementi di M devono essere effettuate seguendo
   l'ordine degli elementi di M, è quindi possibile che un elemento venga prima
   inserito e poi eliminato o viceversa.
   Si assume che  i valori dei campi coD degli elementi di L siano interi
   positivi distinti e che gli elementi siano in ordine crescente rispetto al
   campo coD.
   
   Esempio: L è: {4, "libro"}->{6, "mela"}->{7, "piede"}->{9, "mano"}
   M è: {3, "a"}->{-4, ""}->{-3, "b"}->{5,"poi"}->{7,"per"}->{8,"re"}->{-2,"se"}
   
   L modificata è: {5, "poi"}->{6, "mela"}->{7, "piede"}->{8, "re"}->{9, "mano"}
   */

LDat Mod(LDat L, LDat M){
    
    LDat Ls = L;    // Puntatore di scorrimento della lista settato al 1° nodo
    LDat p;  // Puntatore che punta al predecessore in L del punto da modificare
    LDat nuovonodo;    // Puntatore al nuovo nodo da allocare dinamicamente
    int codcor;    // Valore del campo coD del nodo corrente in M
    
    while(M != NULL){    // Scorri la lista M fino in fondo
        
         codcor = M->coD;
         
         /* Se codcor è minore di 0 verrà eliminato un nodo nella lista L nel
            caso vi sia un elemento con uguale valore del campo coD */
         if(codcor<0){
             
             p = find(L, -(codcor)); // Nodo precedente alla potenziale modifica
             
             /* Se p punta a NULL vuol dire che l'elemento interessato è il
                primo nodo della lista, se il primo nodo della lista ha il campo
                coD uguale a -codcor eliminalo */
             if(p==NULL && L->coD == -(codcor)){
                 Ls = L->next;  // Ls punta al nuovo primo nodo della lista
                 free(L->descr); // Libera la memoria per la stringa
                 free(L);        // Elimina il nodo
                 L = Ls;         // Ora anche L punta al nuovo primo nodo
             }
             
             /* Se l'elemento puntato da (p->next)->next è NULL (non esiste)
                significa che l'elemento puntato da p->next è l'ultimo nodo
                della lista e se il campo coD di p->next è uguale al valore di
                codcor allora sarà eliminato l'ultimo nodo dalla lista */
             else if((p->next)->next == NULL && (p->next)->coD == codcor){
                 (p->next)->next = NULL; /* Setta a NULL il campo next del nodo
                                            puntato da p->next */
                  free((p->next)->descr);
                  free((p->next)->next);
                  Ls=L;
             }
             
             /* Altrimenti si tratta di un elemento mediano posto tra altri due
                nodi della lista */
             
             else{
                 if((p->next)->coD == codcor){
                     /* Setta il valore del campo next del nodo puntato da p
                        con l'indirizzo del nodo successivo a quello puntato da
                        p->next (p->next sarà eliminato e p sarà linkato al suo
                        successivo) */
                     p->next=(p->next)->next;
                     free((p->next)->descr); // Elimina la stringa
                     free(p->next); // Elimina il nodo successivo a p
                     Ls = L;        // Setta Ls al primo nodo della lista L
                 }
             }
         }
         
         /* Se codcor è positivo verrà aggiunto un nodo in caso non esista un
            nodo avente campo coD uguale al valore di codcor */
         else{
            p = find(L, codcor); // Nodo precedente alla potenziale modifica
            
            /* Se il puntatore p è nullo, l'elemento successivo è il primo nodo
               della lista, se il campo coD del primo nodo è diverso da codcor
               allora sarà creato un nuovo primo elemento da linkare alla lista
               */
            if(p == NULL && (L->coD) > codcor){
                nuovonodo = malloc(sizeof(Dat)); // Alloca un nuovo nodo
                /* Alloca dinamicamente la memoria per la stringa puntata dal
                   puntatore contenuto nel campo descr del nuovonodo */
                nuovonodo->descr = malloc(strlen((M->descr)+1)*sizeof(char));
                strcpy(nuovonodo->descr, M->descr); // Copia la stringa
                nuovonodo->next=L; // Setta il campo next al vecchio ptimo nodo
                L=nuovonodo;       // Setta L all'indirizzo del nuovo primo nodo
                Ls=L;              // Setta Ls al primo nodo
            }
            
            /* Se (p->next)->next corrisponde a null significa che l'elemento
               successivo a p (p->next) è l'ultimo nodo della lista.
               Se il campo coD dell'ultimo nodo è minore del valore di codcor
               allora bisogna linkare un nuovo ultimo nodo */
               
            if((p->next)->next == NULL && (p->next)->coD < codcor){
                nuovonodo = malloc(sizeof(Dat)); // Alloca un nuovo nodo
                /* Alloca dinamicamente la memoria per la stringa puntata dal
                   puntatore contenuto nel campo descr del nuovonodo */
                nuovonodo->descr = malloc(strlen((M->descr)+1)*sizeof(char));
                strcpy(nuovonodo->descr, M->descr); // Copia la stringa
                (p->next)->next=nuovonodo;
                nuovonodo->next=NULL; // è l'ultimo nodo
                Ls=L;
            }
            
            /* Altrimenti è un nodo mediano, se il campo coD di p->next è
               diverso a codcor crea un nuovo nodo e linkalo */    
            else{
                if((p->next)->coD != codcor){
                    nuovonodo = malloc(sizeof(Dat)); // Alloca un nuovo nodo
                   /* Alloca dinamicamente la memoria per la stringa puntata dal
                     puntatore contenuto nel campo descr del nuovonodo */
                   nuovonodo->descr = malloc(strlen((M->descr)+1)*sizeof(char));
                   strcpy(nuovonodo->descr, M->descr); // Copia la stringa
                   nuovonodo->next=(p->next)->next;
                   p->next=nuovonodo;
                   Ls=L;
               }
           }
       }    
       return L;
}
       
LDat find(LDat L, int cd){
    
    LDat prev = NULL;
    
    while(cd < L->coD){
        prev = L;
        L = L->next;
    }
    
    return prev;
}

Ancora mille grazie
Andrea

[D4rkAng3l]

uppino...mi sono accorto che nella funziona ausiliaria c'è un errorino nel ciclo di scorrimento della lista e poi anche nella parte dell'eliminazione dell'ultimo nodo mi pare che c'era qualcosa che non andava...apparte questo?dite che fà schifo come soluzione?