Newsgroup: it.comp.lang.c
Titolo: problema

Salve a tutti ho il seguente problema da porvi:
come posso implementare una lista concatenata dove ogni nodo della lista 
  contiene un riferimento ad un'altra lista concatenata?
Grazie a chi vorrà aiutarmi


Esattamente dove sta il problema ?
Si tratta di una normalissima lista concatenata
definendo la struttura della quale
inserisci tra gli altri campi un campo che conterra'
un puntatore a nodi della seconda.
Cosa ti perplime ?
ciao,
g.

nano bagonghi ha scritto:

Il problema sta nel fatto che non mi funziona... Probabilmente mi sfugge 
qualcosa. In pratica devo simulare una prenotazione di biglietti aerei, 
con un numero N di voli e per ciascun volo un numero N di passeggeri. 
Queste sono le strutture che sto usando per le due liste:
________________________________________________________________________
typedef struct list_node_voli *list_pointer_voli;
typedef struct list_node_pass *list_pointer_pass;
/* struttura lista dei voli */
typedef struct list_node_voli
         {
         char nome_volo[60];
         list_pointer_voli link_volo;
         list_pointer_voli link_pass;
         } lista_voli;
list_pointer_voli testa_voli = NULL; // puntatore alla testa della lista 
voli
/* struttura lista dei passeggeri */
typedef struct list_node_pass
         {
         char nome_pass[30];
         list_pointer_pass link;
         } lista_passeggeri;
list_pointer_pass testa_pass = NULL; // puntatore alla testa della lista 
passeggeri
___________________________________________________________________________
In questo modo link_pass dovrebbe diventare la testa della lista dei 
passeggeri per ogni nodo, ma eseguendo il programma si blocca proprio 
quando deve creare le liste dei passeggeri.
Se è utile posso postare tutto il programmino, ciao

 Se è utile posso postare tutto il programmino, ciao
Diciamo che senza vedere il listato e' quasi impossibile trovare
l'errore.
Comunque di solito le cose sbagliate sono 2
1) non allochi la memoria per i record
2) non inizializzi i puntatori.
In ogni caso potresti
1) imparare ad usare un debuggere e seguire
passo passo il tuo programma per vedere dove si pianta
2) "eseguire" sulla carta il tuo programma con
l'ausilio di un bel foglio largo dove annotarsi l'evoluzione
delle variabili ad ogni passo del programma.
Per programmi "giocattolo" questo approccio dovrebbe funzionare
sempre.
ciao,
g.

nano bagonghi ha scritto:

ok proverò con un debugger, grazie

         } lista_voli;

AnalogFile ha scritto:

Si grazie il codice è:
__________________________________________________________________
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define IS_FULL(ptr) (!(ptr))
#define IS_EMPTY(ptr) (!(ptr))
/* dichiarazione struttura lista */
typedef struct list_node_voli *list_pointer_voli;
typedef struct list_node_pass *list_pointer_pass;
typedef struct list_node_voli
         {
         char nome_volo[60];
         list_pointer_voli link_volo;
         list_pointer_pass link_pass;
         } lista_voli;
list_pointer_voli testa_voli = NULL; // puntatore alla testa della lista 
voli
typedef struct list_node_pass
         {
         char nome_pass[30];
         list_pointer_pass link;
         } lista_passeggeri;
//list_pointer_pass testa_pass = NULL; // puntatore alla testa della 
lista passeggeri
void crea_lista_pass(list_pointer_pass *testa_pass, char nome[]);
void insert_testa_pass(list_pointer_pass *ptr, char nome[]);
void insert_dopo_pass(list_pointer_pass *ptr, list_pointer_pass nodo, 
char nome[]);
void crea_lista_voli(list_pointer_voli *testa_voli, char partenza[], 
char nome[]);
void insert_testa_voli(list_pointer_voli *ptr, char partenza[], char 
nome[]);
void insert_dopo_voli(list_pointer_voli *ptr, list_pointer_voli nodo, 
char partenza[], char nome[]);
list_pointer_voli ricerca(list_pointer_voli ptr, char stringa[]);
void visualizza_voli(list_pointer_voli ptr);
void visualizza_pass(list_pointer_pass ptr);
main()
       {
        int scelta;
        char partenza[60];
        char destinazione[30];
        char nome[30];
        list_pointer_voli temp;
        list_pointer_pass ptr;
        do
          {
          printf("\n\nPrenotazione biglietto aerei\n\n");
          printf("1. Prenotazione biglietto\n");
          printf("2. Annulla prenotazione\n");
          printf("3. Controlla prenotazione\n");
          printf("4. Visualizza elenco voli\n");
          printf("5. Visualizza elenco passeggeri\n");
          printf("0. Esci\n");
          printf("\nEsegui una scelta: ");
          scanf("%d" ,&scelta);
          switch(scelta)
              {
              case 1:
                    fflush(stdin);
                    printf("\nPrenotazione biglietto\n");
                    printf("\nPartenza da: ");
                    scanf("%[^\n]s", partenza);
                    fflush(stdin);
                    printf("\nDestinazione: ");
                    scanf("%[^\n]s", destinazione);
                    fflush(stdin);
                    printf("\nInserisci Nome: ");
                    scanf("%[^\n]s", nome);
                    fflush(stdin);
                    strcat(partenza, destinazione);
                    temp = ricerca(testa_voli, partenza);
                    if(temp)
                         {
                         printf("\nVolo: %s", temp->nome_volo);
                         crea_lista_pass(&temp->link_pass, nome); 
                         }
                    else
                        {
                        printf("\n\nIl volo non esiste");
                        crea_lista_voli(&testa_voli, partenza, nome);
                        }
                    break;
              case 4:
                    printf("\nVisualizza elenco voli\n\n");
                    visualizza_voli(testa_voli);
                    break;
              case 5:
                    fflush(stdin);
                    printf("\nVisualizza elenco passeggeri\n\n");
                    printf("\nInserisci volo: ");
                    scanf("%[^\n]s", partenza);
                    fflush(stdin);
                    //visualizza_voli(testa_voli);
                    temp = ricerca(testa_voli, partenza);
                    if(temp)
                        {
                        //ptr = temp->link_pass;
                        //printf("\nVOLO %s\n\n", temp->nome_volo);
                        visualizza_pass(temp->link_pass);
                        //printf("\nPasseggeri per il volo: %s\n\n", 
temp->link_pass);
                        }
                    else
                        printf("\nNon ci sono prenotazioni il volo 
%s\n\n", partenza);
                    break;
              case 0:
                    printf("\n\nFine!");
                    break;
              }
          }
        while(scelta != 0);
        fflush(stdin);
        getchar();
       }
/* crea la lista voli */
void crea_lista_voli(list_pointer_voli *testa_voli, char partenza[], 
char nome[])
     {
     list_pointer_voli nodo, ptr;
     ptr = *testa_voli;
     nodo = ptr;
     if(ptr && ((strcmp(ptr->nome_volo, partenza)) > 0)) // mettiamo > 
perchè la lista deve essere in ordine crescente
            insert_testa_voli(testa_voli, partenza, nome);
     else
         {
         for(; (ptr && ((strcmp(ptr->nome_volo, partenza)) < 0)); ptr = 
ptr->link_volo) // trova la posizione in cui inserire l'elemento
               nodo = ptr;
         insert_dopo_voli(testa_voli, nodo, partenza, nome); // il 1° 
inserimento viene fatto da insert_dopo
         }
     }
/* inserimento in testa della lista voli */
void insert_testa_voli(list_pointer_voli *ptr, char partenza[], char 
nome[]) // ptr per non modificare la testa della lista
      {
      list_pointer_voli temp;
      list_pointer_pass temp_pass;
      temp_pass = NULL;
      temp = (list_pointer_voli)malloc(sizeof(struct list_node_voli));
      if(IS_FULL(temp))
          {
          printf("La memoria e' piena");
          exit(1);
          }
      strcpy(temp->nome_volo, partenza);
      temp->link_volo = *ptr;
      temp->link_pass = temp_pass;
      *ptr = temp;
      crea_lista_pass(&temp_pass, nome);
      }
/* inserimento dopo un elemento della lista voli */
void insert_dopo_voli(list_pointer_voli *ptr, list_pointer_voli nodo, 
char partenza[], char nome[])
      {
      list_pointer_voli temp;
      list_pointer_pass temp_pass;
      temp_pass = NULL;
      temp = (list_pointer_voli)malloc(sizeof(struct list_node_voli));
      if(IS_FULL(temp))
          {
          printf("La memoria e' piena");
          exit(1);
          }
      strcpy(temp->nome_volo, partenza);
      if(*ptr) // controlla se ptr = NULL nel caso è il 1° inserimento
          {
          temp->link_volo = nodo->link_volo; // inserimento dopo nodo 
          nodo->link_volo = temp;
          temp->link_pass = temp_pass;
          crea_lista_pass(&temp_pass, nome);
          }
      else
          {
          temp->link_volo = NULL; // 1° inserimento nella lista
          temp->link_pass = temp_pass;
          crea_lista_pass(&temp_pass, nome);
          *ptr = temp;
          }
      }
/* crea la lista passeggeri */
void crea_lista_pass(list_pointer_pass *testa_pass, char nome[])
     {
     list_pointer_pass nodo, ptr;
     ptr = *testa_pass;
     nodo = ptr;
     if(ptr && ((strcmp(ptr->nome_pass, nome)) > 0)) // mettiamo > 
perchè la lista deve essere in ordine crescente
            insert_testa_pass(testa_pass, nome);
     else
         {
         for(; (ptr && ((strcmp(ptr->nome_pass, nome)) < 0)); ptr = 
ptr->link) // trova la posizione in cui inserire l'elemento
               nodo = ptr;
         insert_dopo_pass(testa_pass, nodo, nome); // il 1° inserimento 
viene fatto da insert_dopo
         }
     }
/* inserimento in testa della lista passeggeri */
void insert_testa_pass(list_pointer_pass *ptr, char nome[]) // ptr per 
non modificare la testa della lista
      {
      list_pointer_pass temp;
      temp = (list_pointer_pass)malloc(sizeof(struct list_node_pass));
      if(IS_FULL(temp))
          {
          printf("La memoria e' piena");
          exit(1);
          }
      strcpy(temp->nome_pass, nome);
      temp->link = *ptr;
      *ptr = temp;
      }
/* inserimento dopo un elemento della lista passeggeri */
void insert_dopo_pass(list_pointer_pass *ptr, list_pointer_pass nodo, 
char nome[])
      {
      list_pointer_pass temp;
      temp = *ptr;
      temp = (list_pointer_pass)malloc(sizeof(struct list_node_pass));
      if(IS_FULL(temp))
          {
          printf("La memoria e' piena");
          exit(1);
          }
      strcpy(temp->nome_pass, nome);
      if(*ptr) // controlla se ptr = NULL nel caso è il 1° inserimento
          {
          temp->link = nodo->link; // inserimento dopo nodo
          nodo->link = temp;
          }
      else
          {
          temp->link = NULL; // 1° inserimento nella lista
          *ptr = temp;
          printf("NOME: %s", temp->nome_pass);
          }
      }
  /* ricerca prenotazione */
list_pointer_voli ricerca(list_pointer_voli ptr, char partenza[])
      {
      list_pointer_voli temp;
      temp = ptr;
      if(temp == NULL)
          {
          //printf("\n\nNon ci sono prenotazioni!");
          return NULL;
          }
      else
          {
          for(; (temp && (strcmp(temp->nome_volo, partenza))); temp = 
temp->link_volo);
          /* quando usciamo dal ciclo for temp punta all'elemento cercato */
          if(temp)
              {
              //printf("La prenotazione e' stata trovata");
              return temp;
              }
          else
              {
              //printf("\n\nLa prenotazione non e' stata trovata!");
              return NULL;
              }
          }
      }
/* visualizza elenco voli */
void visualizza_voli(list_pointer_voli ptr)
      {
      int cont = 0;
      if(IS_EMPTY(ptr))
           {
           printf("\nLa lista e' vuota");
           return;
           }
      for(; ptr; ptr = ptr->link_volo)
            {
            cont++;
            printf("Volo %d: %4s\n", cont, ptr->nome_volo);
            }
      }
/* visualizza elenco passeggeri per volo */
void visualizza_pass(list_pointer_pass ptr)
      {
      int cont = 0;
      if(IS_EMPTY(ptr))
           {
           printf("\nLa lista e' vuota");
           return;
           }
      for(; ptr; ptr = ptr->link)
            {
            cont++;
            printf("Passeggero %d: %4s\n", cont, ptr->nome_pass); 
            }
      }
____________________________________________________________________________
ho risolto dei problemi ma non è tutto a posto, se qualcuno vuole 
perderci un pò di tempo... Grazie