è la pazienza che mi manca! Ieri sera non so per quale motivo non mi compilava anche dopo la modifica che ho ftto grazie al primo che mi ha risp, stamattina ho compilato. Poi mi sono accorto di aver sbagliato un pò di cosette varie, impostato sbagliate condizioni di terminazione ai cicli ecc...
Ora funziona tutto, e tanto per dare un briciolo di soddisfazione a chi mi ha aiutato vi incollo il codice corretto:
codice:
/**********************/
/*Definizione dei tipi*/
/**********************/

/*lista di vertici*/
typedef struct elem_lista_vertici
{
    struct vertice_grafo *vertice;
    struct elem_lista_vertici *next;
}elem_lista_vertici_t;

/*tipo colore*/
typedef enum {bianco, nero, grigio} colore_t;

/*struttura vertice*/
typedef struct vertice_grafo
{            
    int nome;
    double fitness;
    struct vertice_grafo *next;
    struct arco_grafo *lista_archi;
    int distanza;
    struct vertice_grafo *padre;
    colore_t colore;
} vertice_grafo_t;
   
/*struttura arco*/
typedef struct arco_grafo
{
    double peso;
    struct vertice_grafo *vertice_adiac;
    struct arco_grafo *next;
} arco_grafo_t;

/*QUA MANCA IL MAIN MA E' SOLO LA ACQUISIZIONE DI UN GRAFO DA FILE E CHIAMATA ALLA FUNZIONE  avvia_visita_grafo_amp*/
/**************************************************************/
/*Definizione della funzione per avviare la visita di un grafo*/
/**************************************************************/

void avvia_visita_grafo_amp(vertice_grafo_t *grafo)
{
    vertice_grafo_t *vertice;
    
    /*scorro tutti i vertici e li metto a distanza infinita, li coloro di bianco e metto il puntatore al padre a NULL*/
    for(vertice = grafo; vertice != NULL; vertice = vertice->next)
    {
        //printf("Sto scorrendo il vertice con nome %d.\n", vertice->nome);
        vertice->colore = bianco;
        vertice->distanza = -1;
        vertice->padre = NULL;
    }
    
    /*scorro la lista appena aggiornata e per ogni vertice bianco lo visito in ampiezza*/
    for(vertice = grafo; vertice != NULL; vertice = vertice->next)
    {

        if(vertice->colore == bianco)
        {
            getchar();
            printf("Comincia la visita in ampiezza partendo dal vertice %d.\n", vertice->nome);
            visita_grafo_amp(vertice);
        }
    }
}

/*************************************************************/
/*Definizione della funzione per visitare in ampiezza un nodo*/
/*************************************************************/

void visita_grafo_amp(vertice_grafo_t *vertice_partenza)
{
     vertice_grafo_t *vertice;
     arco_grafo_t *arco;
     elem_lista_vertici_t *uscita, *ingresso, *elem;
     
     /*coloro il vertice corrente di grigio e lo metto a dist 0 da se stesso*/
     vertice_partenza->colore = grigio;
     vertice_partenza->distanza = 0;
     /*inizializzo la coda*/
     uscita = ingresso = NULL;
     /*metto in coda il vertice di partenza*/
     metti_in_coda(&uscita, &ingresso, vertice_partenza);
     /*finchè la coda non è vuota*/
     while(uscita != NULL)
     {
         elem = togli_da_coda(&uscita, &ingresso);
         vertice = elem->vertice;
         printf("Estratto dalla lista vertice %d \n",vertice->nome);/*FUNZIONE ELABORA*/
         /*scorro la lista archi di questo vertice*/
         for(arco = vertice->lista_archi; arco != NULL; arco = arco->next)
         {
              /*se il vertice di arrivo dell'arco è bianco*/
              if(arco->vertice_adiac->colore == bianco)
              {
                  /*coloro il vertice di arrivo di grigio, lo metto a distanza +1 da vertice di partenza e metto che suo padre è il vertice di partenza*/
                  arco->vertice_adiac->colore = grigio;
                  arco->vertice_adiac->distanza = vertice->distanza + 1;
                  arco->vertice_adiac->padre = vertice;
                  /*metto in coda il vertice di arrivo di questo arco*/
                  metti_in_coda(&uscita, &ingresso, arco->vertice_adiac);
              }

         }
     vertice->colore = nero;
     }
     
}

/******************************************/
/*Definizione della funzione metti_in_coda*/
/******************************************/

void metti_in_coda(elem_lista_vertici_t **uscita, elem_lista_vertici_t **ingresso, vertice_grafo_t *vertice_partenza)
{
     elem_lista_vertici_t *nuovo;
     
     nuovo = (elem_lista_vertici_t *)malloc(sizeof(elem_lista_vertici_t));
     nuovo->vertice = vertice_partenza;
     nuovo->next = NULL;
     if(*ingresso != NULL)
     {
         (*ingresso)->next = nuovo;
     }
     else
     {
         *uscita = nuovo;
     }
     *ingresso = nuovo;
}

/******************************************/
/*Definizione della funzione togli_da_coda*/
/******************************************/

elem_lista_vertici_t *togli_da_coda(elem_lista_vertici_t **uscita, elem_lista_vertici_t **ingresso)
{
    elem_lista_vertici_t *elem;
    
    elem = *uscita;
    if(*uscita != NULL)
    {
        *uscita = (*uscita)->next;
        if(*uscita == NULL)
        {
            *ingresso = NULL;
        }
    }
    return(elem);
}