Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - [C] ordinamento lista e stampa su file
Forum - C/C++ - [C] ordinamento lista e stampa su file

Avatar
giova87 (Normal User)
Newbie


Messaggi: 3
Iscritto: 11/02/2011

Segnala al moderatore
Postato alle 12:18
Venerdì, 11/02/2011
Salve a tutti!Sono nuovo nel forum,ho guardato un po' le vostre discussioni ma non ho trovato nulla che mi potesse aiutare per evitare di fare repost!
Ho un problema..
In questo codice io devo leggere un file contenente parole delimitate da un numero variabile di spazi e devo creare un file contenente le parole e la loro relativa frequenza, in modo decrescente. La lettura da file dovrebbe avvenire in modo corretto, il problema sorge nell'ordinamento della lista e nella conseguente stampa su file.
Spero che ci sia qualche buon anima che mi possa rispondere e aiutare!
Grazie in anticipo!

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>              //Direttive al pre processore che ci permettono di includere
  2. #include <string.h>             //gli haeder file,relativi a librerie standar.
  3. #include <stdlib.h>
  4. #include <limits.h>
  5. #include <assert.h>
  6.  
  7.  
  8. // definizione della funzione ASSERT()  con stampa di un messaggio di errore
  9. #define ASSERT( condizionedaverificare, cosafare )      { if ( !(condizionedaverificare) ) { printf cosafare; printf("\n"); assert( condizionedaverificare ); } }
  10.  
  11.                        
  12.  
  13. struct lista{                                                   //Dichiarazione della lista usata dalla funzione aggiuntiva
  14.         char parola[257];                                       //Dichiarazione di un array di lunghezza massima 1024 adibito a contenere la parola
  15.         int frequenza;                                          //Dichiarazione di una varibile adibita a contenere la frequenza della parola
  16.         struct lista *next;                                     //Dichiarazione di un puntatore per lo spostamento all'interno della lista
  17.         };
  18.  
  19.  
  20.                                                
  21. int main(int argc, char *argv[])
  22. {
  23.                 char *nomeDelFile=NULL;                                         //puntatore al nome del file da comprimere o decomprimere
  24.                 char *centoParole=NULL;
  25.                
  26.                 char *pra=NULL;
  27.                 FILE *fileTesto=NULL;
  28.                 FILE *fpw=NULL ;
  29.                 int contaLettere=0;
  30.                 int numero_parole=0;
  31.                 int massimo=0;
  32.                 char bufferLettura[256];
  33.                 struct lista *nuovo=NULL;
  34.                 struct lista *testa=NULL;
  35.                 struct lista *temp=NULL;
  36.                 struct lista *prev=NULL;
  37.                 struct lista *canc=NULL;
  38.                
  39.                
  40.                
  41.                 if(argc!=2)                                                             //controllo sul numero di parametri per far partire il programma che devono essere: <nome programma> <nome file>
  42.                 {                                                      
  43.                         printf("\nErrore!Indicare il nome del file da comprimere o da decomprimere\n");
  44.                         exit(1);
  45.                 }      
  46.                
  47.                 nomeDelFile=argv[1];                                    //copio il contenuto di argv[1] che contiene il nome del file da comprimere/decomprimere
  48.                
  49.                
  50.         centoParole = (char*)malloc(sizeof(char)*(strlen(nomeDelFile)+7));     
  51.         strncpy(centoParole,nomeDelFile,strlen(nomeDelFile));                                                                          
  52.         strncat(centoParole,".world\0",7);             
  53.        
  54.        
  55.  
  56.        
  57.         fileTesto=fopen(nomeDelFile,"r");                                                       //apertura del file di testo in modalità lettura
  58.                
  59.         fpw=fopen(centoParole,"w");                                                                     //apertura del file di testa in cui devo andare a scrivere
  60.         assert(fpw != NULL);   
  61.        
  62.  
  63.         while(!feof(fileTesto))
  64.         {
  65.                
  66.                 contaLettere=0;                                                         //Indicizzazione a 0 della variabile i
  67.                
  68.                
  69.                         pra = (char*)malloc( 256 * sizeof(char));
  70.                         memset(pra,0,256 * sizeof(char));
  71.  
  72.                         fscanf(fileTesto,"%s", pra);
  73.                         strcpy(bufferLettura,pra);
  74.                        
  75.                        
  76.                         contaLettere=strlen(bufferLettura);
  77.                         free(pra);
  78.                         if(contaLettere<256)
  79.                         {
  80.                                 bufferLettura[contaLettere]='\0';
  81.                         }
  82.                         else
  83.                         {
  84.                                 bufferLettura[0]='\0';
  85.                         }
  86.                        
  87.  
  88.        
  89.                 if(bufferLettura[0]!='\0')      //guardare soluzioni alternative per  parole maggiori di 256 caratteri
  90.                  {     
  91.                        
  92.                         prev = NULL;
  93.                         temp=testa;            
  94.                         while((temp != NULL) && (strcmp(bufferLettura,temp->parola) != 0)){
  95.                                        
  96.                                         prev = temp;
  97.                                         temp = temp->next;                                                                      //Incremento il puntatore per avanzare nella scansione della lista                                             
  98.                                        
  99.                         }
  100.                        
  101.                        
  102.                         if (temp == NULL)
  103.                         {
  104.                                
  105.                                 nuovo=(struct lista*)malloc(sizeof(struct lista));      //Allocazione dinamica della memoria di una nuova cella della lista tramite la funzione malloc
  106.                                 strncpy(nuovo->parola,bufferLettura,contaLettere);
  107.                                
  108.                                 nuovo->frequenza=1;                                                                     //Impostazione della frequenza della parola a 1
  109.                                 nuovo->next = NULL;
  110.                                 if (testa != NULL)
  111.                                         prev->next = nuovo;
  112.                                 else testa = nuovo;
  113.                                
  114.                         }
  115.                         else temp->frequenza++;
  116.                 }
  117.         }      
  118.  
  119.        
  120.         temp=testa;                                    
  121.        
  122.         if(testa==NULL)
  123.         {      
  124.                 fclose(fpw);           
  125.                 exit(0);                       
  126.         }
  127.         else
  128.                 {
  129.                         while(temp != NULL && numero_parole <= 100 )
  130.                         {
  131.                                 massimo=0;                                                                     
  132.                                 while(temp != NULL)     //ciclo per trovare il massimo
  133.                                 {                              
  134.                                         if(temp->frequenza > massimo)
  135.                                         {                      
  136.                                                 massimo=temp->frequenza;
  137.                                         }                      
  138.                                         temp=temp->next;                                               
  139.                                 }
  140.                                
  141.                                 temp=testa;                                                                    
  142.                                                                                                        
  143.                                 while(temp != NULL)
  144.                                 {                                              
  145.                                         if(temp->frequenza == massimo)
  146.                                         {                              
  147.                                                 fprintf(fpw,"%d %s \r\n",temp->frequenza,temp->parola);
  148.                                                 numero_parole++;
  149.                                                 prev->next=temp->next;
  150.                                                 canc=temp;
  151.                                                 temp=temp->next;
  152.                                                 free(canc);
  153.                                                
  154.                                         }
  155.                                         else
  156.                                                 {
  157.                                                         prev=temp;
  158.                                                         temp=temp->next;
  159.                                                 }                                              
  160.  
  161.                                 }
  162.  
  163.                         }
  164.                 }
  165.  
  166. fclose(fileTesto);
  167. fclose(fpw);
  168.  
  169.                 return 0;
  170. }


PM Quote
Avatar
Bonny (Member)
Expert


Messaggi: 435
Iscritto: 24/04/2009

Segnala al moderatore
Postato alle 14:47
Venerdì, 11/02/2011
Ti mostro come io creo una lista ordinata con qst funzione:
Codice sorgente - presumibilmente C++

  1. // struttura del nodo
  2. typedef struct dato{      
  3.                       int n;
  4.                       char nome[10];
  5.                  }element_type;
  6.                  
  7. typedef struct elemento {
  8.                              element_type value;
  9.                              struct elemento *next;
  10.                           } nodo;
  11.                                                  
  12. typedef nodo *list;
  13. //var globale
  14. list L = NULL;
  15. //crea una lista ordinata in ordine crescente in base al numero
  16. list cons_sort(element_type e, list l){
  17.  
  18.     list newp;// puntatore al nuovo nodo
  19.     list prov;// puntatore al nodo precedente della lista
  20.     list cur;// puntatore al nodo corrente della lista
  21.    
  22.     newp = (list)malloc(sizeof(nodo));//crea il nuovo nodo
  23.    
  24.     newp->value.n = e.n;
  25.     strcpy(newp->value.nome,e.nome);//memorizza valore nel nodo
  26.     newp->next = NULL; // il nodo nn è collegato a nessun altro nodo
  27.    
  28.     prov = NULL;
  29.     cur = l;
  30.     //esegue un ciclo per trovare la posizione corretta nella lista
  31.     while(cur != NULL && (e.n > cur->value.n)){
  32.              
  33.               prov = cur;     //passa al....
  34.               cur = cur->next;//...prossimo nodo            
  35.               }
  36.                          
  37.                 if(prov == NULL){//inserisce il nodo in testa alla lista
  38.                       newp->next = l;
  39.                       l = newp;
  40.                    }else{//inserisce il nodo tra prov e curr
  41.              
  42.                    prov->next = newp;
  43.                    newp->next = cur;
  44.                 }
  45.    return l;        
  46. }


Ultima modifica effettuata da Bonny il 11/02/2011 alle 14:49


Bonny
PM Quote