Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - ordinamento
Forum - C/C++ - ordinamento - Pagina 5

Pagine: [ 1 2 3 4 5 ] Precedente | Prossimo
Avatar
gantonio (Normal User)
Guru^2


Messaggi: 1532
Iscritto: 09/09/2007

Segnala al moderatore
Postato alle 15:50
Giovedė, 12/06/2008
Testo quotato

Postato originariamente da volley.sil:

mi puoi dire almeno qyuali sono gli errori concettuali fi cui parli???



Essenzialmente il problema sta nella

list

Tu allochi un sacco di memoria (inutilmente) e la tratti come un puntatore a char. Invece dovrebbe essere un puntatore a un vettori di puntatori a char, ovvero un vettore di stringhe, in C, un doppio puntatore a char

char **list;

Di conseguenza tutte le funzioni non sono corrette, e in particolare la readlist che non legge correttamente da file le linee contenute.

Insomma, e' praticamente da rifare ... e "lavorarci" significa rifarlo ... sincerament non ne ho il tempo ...

PM
Avatar
volley.sil (Normal User)
Rookie


Messaggi: 39
Iscritto: 19/05/2008

Segnala al moderatore
Postato alle 17:45
Mercoledė, 25/06/2008
ciao ragazzi,
sapreste dirmi come funziona la funzione strcmp,devo usarla per ordinare delle stringhe con quicksort, prese in input da un file di testo..ma penso che cosė non sia corretto ..
Potreste dare un occhiata al mio sorgente

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5.  
  6.  
  7. void readsize(char *inputlist, int *length, int *size) {
  8.         FILE *in=fopen("inputlist.txt","r");
  9.         int i=0,j=0;
  10.         char tmp;
  11.  
  12.         while(fscanf(in,"%c",&tmp)!=EOF && tmp!='\n') j++;
  13.         rewind(in);
  14.         while(fscanf(in,"%*s\n")!=EOF) i++;
  15.         (*length)=i; (*size)=j;
  16.         fclose(in);
  17. }
  18.  
  19. char *readline(FILE *in,int size) {
  20.         char *line=(char *)malloc(size*sizeof(char)), tmp;
  21.         int i=0;
  22.  
  23.         while(i<size && fscanf(in,"%c",&line[i])!=EOF) i++;
  24.         fscanf(in,"%c",&tmp);
  25.         if(tmp!='\n')
  26.     {
  27.                 printf("Error: malformed file\n");
  28.                 return NULL;
  29.         }
  30.  
  31.         return line;
  32. }
  33.  
  34. char **loadlist(char *inputlist, int *length, int *size) {
  35.         int i;
  36.         char **list;
  37.         FILE *in=fopen("inputlist.txt","r");
  38.  
  39.         readsize(inputlist,length,size);
  40.  
  41.         list=(char **)malloc((*length)*sizeof(char *));
  42.  
  43.         for(i=0; i<(*length); i++)
  44.                 list[i]=readline(in,(*size));
  45.                
  46.         fclose(in);
  47.  
  48.         return list;
  49. }
  50. void exchange(char *list, int i, int j) {
  51.         int tmp=list[i];
  52.         list[i]=list[j];
  53.         list[j]=tmp;
  54. }
  55.  
  56. int partition(char *list, int p, int r) {
  57.         int i=p, j=r, x, pivot, v;
  58.  
  59.         x=rand()%(r-p+1)+p;
  60.         exchange(list,x,p);
  61.         pivot=list[p];
  62.         v=strcmp((const char*)p,(const char*)r) ;
  63.         while(v>0)
  64.    {
  65.                 while(strcmp((const char*)j,(const char*)p)<0 && list[j]>pivot)
  66.           j--;
  67.                 while(strcmp((const char*)i,(const char*)r)>0 && list[i]<=pivot) i++;
  68.                 if(strcmp((const char*)i,(const char*)j)>0)
  69.           exchange(list,i,j);
  70.         }
  71.         exchange(list,p,j);
  72.         return j;
  73. }
  74. void sortlist (char **list, int p, int r) {
  75.         int q;
  76.        
  77.        
  78.         //f(strcmp((const char*)p,(const char*)r)<0)
  79.         if(p<r)
  80.     {
  81.                 q=partition(*list,p,r);
  82.                 sortlist(list,p,q-1);
  83.                 sortlist(list,q+1,r);
  84.         }
  85. }
  86. void printlist(char *outputlist, char **list, int length)
  87. {
  88.         int i;
  89.         FILE *out=fopen("outputlist.txt","w");
  90.        
  91.         for(i=0; i<length; i++)
  92.                 fprintf(out,"%s",list[i]);
  93.         fprintf(out,"\n");
  94.         fclose(out);
  95. }
  96. int main(int argc, const char *argv[]) {
  97.  
  98.     char **list;       
  99.         int length,size;
  100.         time_t start, end;
  101.  
  102.         if(argc!=3)
  103.     {
  104.                 printf("Usage: stringsort <input list> <output list>\n");
  105.                 return 1;
  106.         }
  107.  
  108.         list=loadlist((char *)argv[1],&length,&size);
  109.         start=clock();
  110.         sortlist(list,length,size);
  111.         end=clock();
  112.                
  113.         printf("%g\n",(int)(end-start)/(int)CLOCKS_PER_SEC);
  114.         printlist((char *)argv[2],list,length);
  115.  
  116.         return 0;
  117.        
  118. }



Grazie

PM
Avatar
eddiewrc (Member)
Expert


Messaggi: 560
Iscritto: 30/04/2006

Segnala al moderatore
Postato alle 19:17
Giovedė, 07/08/2008
io sono dell'idea che tutto ciō sia scandaloso... all'universitā si dovrebbero imparare le cose, mica elemosinare aiuto in internet.. anche a me capita di chiedere qualcosa a chi ne sa di +(anche su questo forum), perō io penso che sia lecito se si tratta di un consiglio su che direzione prendere o un parere, non č che si piazzano nel topic le specifiche del progetto e si aspetta che qualcuno risolva tutto!

tra l'altro molte domande denotano proprio il fatto che la voglia di prendere un manuale e leggere 2 righe č assolutamente nulla... si aspetta che qualcuno prepari la pappa!

PM
Avatar
luca260786 (Normal User)
Rookie


Messaggi: 22
Iscritto: 10/01/2008

Segnala al moderatore
Postato alle 17:59
Giovedė, 18/06/2015
Buongiorno a tutti, riprendo questa vecchia discussione perchč ho un problema di ordinamento con l'algoritmo quicksort ovviamente da me implementato. Il problema č il seguente:
Ho una lista di automobili, se l'utente inserisce una nuova vettura identica, per esempio 2 clio con gli stessi identici dati tranne che per il codice del telaio essendo univoco, l'ordinamento va in un loop infinito, mi chiedo come mai? Dovrebbe semplicemente scambiare per marca o modello o gli altri criteri, perchč non accade? Cosa manca? Di seguito il codice sorgente completo.

Codice sorgente - presumibilmente C++

  1. /**********************************************************************************/
  2. /* Programma per la gestione commerciale di una attivitā di vendita di Automobili */
  3. /**********************************************************************************/
  4.  
  5. /***************************/
  6. /* Autore: Luca Mencarelli */
  7. /***************************/
  8.  
  9. /*****************************/
  10. /* Inclusione delle Librerie */
  11. /*****************************/
  12.  
  13. #include <stdio.h>
  14. #include <string.h>
  15. #include <stdlib.h>
  16.  
  17. /*****************************************/
  18. /* Definizione delle costanti simboliche */
  19. /*****************************************/
  20.  
  21. #define LUNG_STR 20     /* Costante per contenere i dati nei vettori di tipo stringa e nel vettore di tipo intero */
  22. #define MAX_AUTO 2000 /* Costante per il numero massimo di AUTOMOBILI */
  23.  
  24. /************************/
  25. /* Definizione dei tipi */
  26. /************************/
  27.  
  28. /* Struttura dati automobile */
  29. typedef struct automobile
  30. {
  31.         char marca[LUNG_STR + 1];                                       /* Variabile Stringa per la marca dell'automobile */
  32.         char modello[LUNG_STR + 1];                                     /* Variabile Stringa per il modello dell'automobile */
  33.         char colore[LUNG_STR + 1];                                      /* Variabile Stringa per il colore dell'automobile */
  34.         char codice_telaio[LUNG_STR + 1];                       /* Variabile Stringa per il codice del telaio dell'automobile */
  35.         int prezzo;                                                                     /* Variabile Intera per il prezzo dell'automobile */
  36.         struct automobile *vettura_succ;                        /* Puntatore di tipo struttura dati alla vettura successiva */
  37.         struct automobile *vettura_prec;                        /* Puntatore di tipo struttura dati alla vettura precedente */
  38. }automobile_t;
  39.  
  40. /********************************/
  41. /* Dichiarazione delle funzioni */
  42. /********************************/
  43.  
  44. /* Dichiarazione delle funzioni di utilitā per lista */
  45. void inserisci(char [], char [], char [], char [], int, automobile_t **);                                
  46. automobile_t *rimuovi_vettura(automobile_t *lista, char codice_telaio[]);
  47. void scambia(automobile_t *a, automobile_t *b);
  48. automobile_t *posizione_vettura(automobile_t *testa, int posizione);
  49. void stampa_lista(automobile_t *lista);
  50. void modifica_vettura(automobile_t *lista, int posizione);
  51.  
  52. /* Dichiarazione della funzione scegli_quicksort */
  53. void scegli_quicksort(automobile_t *testa);
  54.  
  55. /* Dichiarazione delle funzioni quicksort */
  56. void quicksort_prezzo(automobile_t *primo_elemento, int indice_sx, int indice_dx);
  57. int ripartizione_prezzo(automobile_t* primo_elemento, int indice_sx, int indice_dx);
  58. void quicksort_marca(automobile_t *primo_elemento, int indice_sx, int indice_dx);
  59. int ripartizione_marca(automobile_t* primo_elemento, int indice_sx, int indice_dx);
  60. void quicksort_modello(automobile_t *primo_elemento, int indice_sx, int indice_dx);
  61. int ripartizione_modello(automobile_t* primo_elemento, int indice_sx, int indice_dx);
  62. void quicksort_colore(automobile_t *primo_elemento, int indice_sx, int indice_dx);
  63. int ripartizione_colore(automobile_t* primo_elemento, int indice_sx, int indice_dx);
  64. void quicksort_codice_telaio(automobile_t *primo_elemento, int indice_sx, int indice_dx);
  65. int ripartizione_codice_telaio(automobile_t* primo_elemento, int indice_sx, int indice_dx);
  66.  
  67. /* Dichiarazione delle funzioni di utilitā generale */
  68. void media_prezzi(automobile_t *lista);
  69. void mediana_prezzi(automobile_t *lista);
  70. int conta_automobili(automobile_t* testa);
  71. int somma_prezzi(automobile_t *testa);
  72. void valutazione_sperimenta(automobile_t *lista, int n);
  73.  
  74. /* Definizione della funzione main */
  75. int main(void)
  76. {
  77.         /* Dichirazione delle variabili locali alla funzione */
  78.         char marca[LUNG_STR + 1];                                       /* Variabile Stringa per la marca dell'automobile */
  79.         char modello[LUNG_STR + 1];                                     /* Variabile Stringa per il modello dell'automobile */
  80.         char colore[LUNG_STR + 1];                                      /* Variabile Stringa per il colore dell'automobile */
  81.         char codice_telaio[LUNG_STR + 1];                       /* Variabile Stringa per il codice del telaio dell'automobile */
  82.         int prezzo;                                                                     /* Variabile Intera per il prezzo dell'automobile */
  83.         int scelta = 0;                                                         /* Lavoro: Variabile per la scelta da parte dell'utente */
  84.         int posizione = 0;                                                      /* Lavoro: Variabile per la posizione della vettura */
  85.         int num_vetture = 0;                                            /* Lavoro: Numero vetture da inserire da parte dell'utente */
  86.         int i = 0;                                                                      /* Lavoro: Indice di scorrimento ciclo for per l'inserimento di nuove vetture */
  87.         automobile_t *lista = NULL;                                     /* Lavoro: Puntatore alla lista inizializzato a NULL quindi lista vuota */
  88.        
  89.         /* Ciclo do-while per la scelta da effettuare da parte dell'utente */
  90.         do
  91.         {
  92.                 printf("-----------BENVENUTO NEL PROGRAMMA DI GESTIONE VENDITE DI AUTOMOBILI------------\n");
  93.                 printf("1)Carica l'elenco delle automobili.\n");
  94.                 printf("2)Inserisci nuove informazioni su una nuova automobile.\n");
  95.                 printf("3)Rimuovi una automobile dall'elenco.\n");
  96.                 printf("4)Modifica informazioni di una automobile nell'elenco.\n");
  97.                 printf("5)Ordinamento.\n");
  98.                 printf("6)Stampa media e mediana del prezzo di tutte le automobili presenti in elenco.\n");
  99.                 printf("7)Esci dal programma.\n");
  100.                 printf("\nPrego fare una scelta: ");
  101.                 if(scanf("%d", &scelta) == 1);
  102.                
  103.                 /* Controllo della scelta */
  104.                 switch(scelta)
  105.                 {
  106.                         case 1:
  107.                         {
  108.                                 /* Lettura del file di testo automobili.txt */
  109.                                 FILE *file_automobili = fopen("automobili.txt", "r");
  110.                
  111.                                 /* controllo se il file esiste */
  112.                                 if(file_automobili == NULL)
  113.                         {
  114.                                 printf("\nImpossibile aprire il file di testo automobili!\n");
  115.                                 printf("\nControllare che il file esista nella stessa cartella in cui si esegue il programma\n");
  116.                                         exit(0);
  117.                         }
  118.                
  119.                                 /* Visualizza l'elenco delle automobili */
  120.                                 printf("\n-----------------ELENCO AUTOMOBILI-------------------\n\n");
  121.                
  122.                                 /* Ciclo for fino alla fine del file */
  123.                                 while(!feof(file_automobili))
  124.                                 {
  125.                                         if(fscanf(file_automobili, "%s\t%s\t%s\t%s\t%d", marca,
  126.                                                                                                                          modello,
  127.                                                                                                                          colore,
  128.                                                                                                                          codice_telaio,
  129.                                                                                                                          &prezzo) == 1);
  130.                                        
  131.                                         /* Chiamata alla funzione inserisci */
  132.                                         inserisci(marca, modello, colore, codice_telaio, prezzo, &lista);
  133.                                 }
  134.                                
  135.                                 /* Chiusura del file */
  136.                                 fclose(file_automobili);
  137.                                 stampa_lista(lista);
  138.                                 break;
  139.                         }
  140.                                
  141.                         case 2:
  142.                         {
  143.                                 /* Chiedo all'utente quante nuove vetture vuole inserire */
  144.                                 printf("\nQuante nuove vetture vuoi inserire nella lista? ");
  145.                                        
  146.                                 if(scanf("%d", &num_vetture) == 1)
  147.                                 {
  148.                                         for(i = 0; i < num_vetture; i++)
  149.                                         {
  150.                                                 /* Chiedo all'utente di inserire una nuova automobile */
  151.                                                 printf("Inserisci Marca: ");
  152.                                                 if(scanf("%s",marca) == 1);
  153.                                                 printf("Inserisci Modello: ");
  154.                                                 if(scanf("%s",modello) == 1);
  155.                                                 printf("Inserisci Colore: ");
  156.                                                 if(scanf("%s",colore) == 1);
  157.                                                 printf("Inserisci Telaio: ");
  158.                                                 if(scanf("%s",codice_telaio) == 1);
  159.                                                 printf("Inserisci Prezzo: ");
  160.                                                 if(scanf("%d",&prezzo) == 1);
  161.                                                
  162.                                                 /* Chiamata alla funzione inserisci */
  163.                                                 inserisci (marca,modello,colore,codice_telaio,prezzo,&lista);
  164.                                         }
  165.                                                
  166.                                         /* Chiamata alla funzione stampa_lista */
  167.                                         stampa_lista(lista);
  168.                                 }
  169.                                
  170.                                 break;
  171.                         }
  172.                        
  173.                         case 3:
  174.                         {
  175.                                 /* Chiedo all'utente di inserire il codice del telaio della vettura da rimuovere */
  176.                                 printf("\nInserisci il codice del telaio della vettura da rimuovere: ");
  177.                                 if(scanf("%s", codice_telaio) == 1);   
  178.  
  179.                                 /* Chiamata alla funzione rimuovi_vettura */
  180.                                 rimuovi_vettura(lista, codice_telaio);
  181.                                
  182.                                 /* Chiamata alla funzione stampa_lista */
  183.                                 stampa_lista(lista);
  184.                                 break;
  185.                         }
  186.                        
  187.                         case 4:
  188.                         {
  189.                                 /* Chiedo all'utente di inserire la posizione della vettura */
  190.                                 printf("\nInserisci la posizione della vettura: ");
  191.                                 if(scanf("%d", &posizione) == 1)
  192.                                 {
  193.                                         /* Prendo posizione -1 perchč prevedo che l'utente partirā da 1 e
  194.                                         chiamata alla funzione modifica vettura */
  195.                                         modifica_vettura(lista, posizione - 1);
  196.                                 }
  197.                                
  198.                                 /* Chiamata alla funzione stampa_lista */
  199.                                 stampa_lista(lista);
  200.                                 break;
  201.                         }
  202.                        
  203.                         case 5:
  204.                         {
  205.                                 /* Chiamata alla funzione scegli_quicksort */
  206.                                 scegli_quicksort(lista);
  207.                                
  208.                                 /* Stampo l'elenco delle vetture ordinato in base ad uno dei criteri scelti dall'utente */
  209.                                 printf("\n------------ELENCO ORDINATO-------------\n\n");
  210.                                
  211.                                 /* Chiamata alla funzione stampa_lista */
  212.                                 stampa_lista(lista);
  213.                                 break; 
  214.                         }
  215.                        
  216.                         case 6:
  217.                         {
  218.                                 /* Chiamata alla funzione media_prezzi */
  219.                                 media_prezzi(lista);
  220.                                
  221.                                 /* Nella mediana dei prezzi viene fatto anche l'ordinamento per prezzo
  222.                                         altrimenti non si sa quale/i sono gli elementi centrali */
  223.                                 mediana_prezzi(lista);
  224.                                
  225.                                 /* Chiamata alla funzione stampa_lista */
  226.                                 stampa_lista(lista);
  227.                                 break;
  228.                         }
  229.                        
  230.                         default:
  231.                                
  232.                                 if(scelta < 0 && scelta > 7)
  233.                                 {
  234.                                         printf ("Il Numero selezionato non permette di eseguire alcuna funzione\n");
  235.                                 }
  236.                                 break;
  237.                 }
  238.                
  239.         }
  240.         while(scelta > 0 && scelta < 7);
  241.        
  242.         /* Stampo un messaggio di ringraziamenti per l'utilizzo del software */                        
  243.         printf("\nGrazie per aver utilizzato il programma di Gestione vendite di Automobili.\n");
  244.        
  245.         /* Termina il programma e restituisco il valore 0 al Sistema Operativo */
  246.         return(0);
  247. }
  248.  
  249. /* Definizione della funzione inserisci */
  250. void inserisci(char marca[], char modello[], char colore[],
  251.                                  char codice_telaio[], int prezzo, automobile_t **lista)
  252. {
  253.         /* Dichiarazione delle variabili locali alla funzione */
  254.         automobile_t *nuova_vettura = NULL;
  255.        
  256.         /* Alloco la memoria con la funzione di libreria calloc */
  257.         nuova_vettura = (automobile_t *)calloc(MAX_AUTO, sizeof(automobile_t));
  258.        
  259.         /* Creazione del nuovo nodo */
  260.         strcpy(nuova_vettura->marca, marca);
  261.         strcpy(nuova_vettura->modello, modello);
  262.         strcpy(nuova_vettura->colore, colore);
  263.         strcpy(nuova_vettura->codice_telaio, codice_telaio);
  264.         nuova_vettura->prezzo = prezzo;
  265.  
  266.         /* Inserimento in testa */     
  267.         nuova_vettura->vettura_succ = *lista;
  268.         nuova_vettura->vettura_prec = NULL;
  269.         *lista = nuova_vettura;
  270.        
  271.         /* Collegamento della struttura precedente, necessario per iterare al contrario nella lista */
  272.         if (!(nuova_vettura->vettura_succ == NULL))
  273.         {
  274.                 nuova_vettura->vettura_succ->vettura_prec = nuova_vettura;
  275.         }
  276. }
  277.  
  278. /* Definizione della funzione rimuovi_vettura */
  279. automobile_t *rimuovi_vettura(automobile_t *lista, char codice_telaio[])
  280. {
  281.         automobile_t *vettura_corr, *vettura_prec;      /* Lavoro: Puntatori rispettivamente alla vettura corrente e
  282.                                                                                                    alla vettura prcedente */
  283.        
  284.         /* Ciclo for per richiamare la vettura selezionata dall'utente */
  285.         for(vettura_corr = lista, vettura_prec = NULL;
  286.                 vettura_corr != NULL && strcmp(vettura_corr->codice_telaio, codice_telaio) != 0;
  287.                 vettura_prec = vettura_corr, vettura_corr = vettura_corr->vettura_succ)
  288.                 ;
  289.        
  290.         /* Controllo del puntatore vettura_corr */
  291.         if(vettura_corr == NULL)
  292.         {
  293.                 return lista;
  294.         }
  295.        
  296.         /* Controllo del puntatore vettura_prec */
  297.         if(vettura_prec == NULL)
  298.         {
  299.                 lista = lista->vettura_succ;
  300.         }
  301.         else
  302.         {
  303.                 vettura_prec->vettura_succ = vettura_corr->vettura_succ;
  304.         }
  305.        
  306.         /* Disallocazione della memoria sulla vettura selezionata */
  307.         free(vettura_corr);
  308.        
  309.         return lista;
  310. }
  311.  
  312. /* Definizione della funzione modifica_vettura */
  313. void modifica_vettura(automobile_t *lista, int posizione)
  314. {
  315.         automobile_t *vettura;
  316.         int scelta = 0;
  317.         int prezzo = 0;
  318.         char stringa[LUNG_STR + 1];
  319.        
  320.         if(posizione < conta_automobili(lista))
  321.         {
  322.                 vettura = posizione_vettura(lista, posizione);
  323.                
  324.                 /* modifica dei dati */
  325.                 do
  326.                 {
  327.                         printf("%s\t%s\t%s\t%s\t%d\n", vettura->marca, vettura->modello,
  328.                                                                                    vettura->colore, vettura->codice_telaio,
  329.                                                                                    vettura->prezzo);
  330.                                                                                    
  331.                         printf("\nQuali dati vuoi modificare? ");
  332.                         printf("\n1) Modifica Marca ");
  333.                         printf("\n2) Modifica Modello ");
  334.                         printf("\n3) Modifica Colore ");
  335.                         printf("\n4) Modifica Codice Telaio ");
  336.                         printf("\n5) Modifica Prezzo ");
  337.                         printf("\n\nQualunque altra scelta fara' tornare al menu' principale\n\n");
  338.                         printf("Prego fai la tua scelta: ");
  339.                         if(scanf("%d", &scelta) == 1)
  340.                         {
  341.                                 switch(scelta)
  342.                                 {
  343.                                         case 1:
  344.                                                 {
  345.                                                         printf("Nuova Marca: ");
  346.                                                         if(scanf("%s", stringa) <= LUNG_STR + 1)
  347.                                                         {
  348.                                                                 strcpy(vettura->marca, stringa);
  349.                                                         }
  350.                                                         break;
  351.                                                 }
  352.                                        
  353.                                         case 2:
  354.                                                 {
  355.                                                         printf("Nuovo Modello: ");
  356.                                                         if(scanf("%s", stringa) <= LUNG_STR + 1)
  357.                                                         {
  358.                                                                 strcpy(vettura->modello, stringa);
  359.                                                         }
  360.                                                         break;
  361.                                                 }
  362.                                                
  363.                                         case 3:
  364.                                                 {
  365.                                                         printf("Nuovo Colore: ");
  366.                                                         if(scanf("%s", stringa) <= LUNG_STR + 1)
  367.                                                         {
  368.                                                                 strcpy(vettura->colore, stringa);
  369.                                                         }
  370.                                                         break;
  371.                                                 }      
  372.                                                
  373.                                         case 4:
  374.                                                 {
  375.                                                         printf("Nuovo Codice Telaio: ");
  376.                                                         if(scanf("%s", stringa) <= LUNG_STR + 1)
  377.                                                         {
  378.                                                                 strcpy(vettura->codice_telaio, stringa);
  379.                                                         }
  380.                                                         break;
  381.                                                 }
  382.                                                
  383.                                         case 5:
  384.                                                 {
  385.                                                         printf("Nuovo Prezzo: ");
  386.                                                         if(scanf("%d", &prezzo) == 1)
  387.                                                         {
  388.                                                                 vettura->prezzo = prezzo;
  389.                                                         }
  390.                                                         break;
  391.                                                 }
  392.                                                
  393.                                         default: break;
  394.                                 }
  395.                         }
  396.                 }
  397.                 while (scelta > 0 && scelta < 6);
  398.         }
  399.         else
  400.         {
  401.                 printf("\nPosizione non compresa nella lista\n\n");
  402.         }
  403. }
  404.  
  405. /* Definizione della funzione scegli_quicksort */
  406. void scegli_quicksort(automobile_t *lista)
  407. {
  408.        
  409.         int scelta_ord = 0; /* Lavoro = Variabile per la scelta dell'ordinamento da parte dell'utente */
  410.        
  411.         printf("\n1)Stampa l'elenco ordinato in base alla marca della vettura.\n");
  412.         printf("2)Stampa l'elenco ordinato in base al modello della vettura.\n");
  413.         printf("3)Stampa l'elenco ordinato in base al colore della vettura.\n");
  414.         printf("4)Stampa l'elenco ordinato in base al codice del telaio della vettura.\n");
  415.         printf("5)Stampa l'elenco ordinato in base al prezzo della vettura.\n");
  416.         printf("\nPrego fare una scelta: ");
  417.         if(scanf("%d", &scelta_ord) == 1);
  418.    
  419.         /* Switch per la scelta dell'adeguato ordinamento */
  420.         switch(scelta_ord)
  421.         {
  422.                 case 1:
  423.                         /* chiamata alla funzione quicksort_marca */
  424.                         quicksort_marca(lista, 0, conta_automobili(lista) - 1);
  425.                         break;
  426.                
  427.                 case 2:
  428.                         /* chiamata alla funzione quicksort_modello */
  429.                         quicksort_modello(lista, 0, conta_automobili(lista) - 1);
  430.                         break;
  431.                        
  432.                 case 3:
  433.                         /* chiamata alla funzione quicksort_colore */
  434.                         quicksort_colore(lista, 0, conta_automobili(lista) - 1);
  435.                         break;
  436.                        
  437.                 case 4:
  438.                         /* chiamata alla funzione quicksort_codice_telaio */
  439.                         quicksort_codice_telaio(lista, 0, conta_automobili(lista) - 1);
  440.                         break;
  441.                
  442.                 case 5:
  443.                         /* chiamata alla funzione quicksort_prezzo */
  444.                         quicksort_prezzo(lista, 0, conta_automobili(lista) - 1);
  445.                     break;
  446.                    
  447.                 default: break;
  448.         }
  449. }
  450.  
  451. /* Definizione dela funzione scambia */
  452. void scambia(automobile_t *vettura_a, automobile_t *vettura_b)
  453. {
  454.         char dato[LUNG_STR + 1];
  455.         int prezzo;
  456.        
  457.         /* Scambio la marca della vettura */
  458.         strcpy(dato, vettura_a->marca);
  459.         strcpy(vettura_a->marca, vettura_b->marca);
  460.         strcpy(vettura_b->marca, dato);
  461.        
  462.         /* Scambio il modello della vettura */
  463.         strcpy(dato, vettura_a->modello);
  464.         strcpy(vettura_a->modello, vettura_b->modello);
  465.         strcpy(vettura_b->modello, dato);
  466.        
  467.         /* Scambio il colore della vettura */
  468.         strcpy(dato, vettura_a->colore);
  469.         strcpy(vettura_a->colore, vettura_b->colore);
  470.         strcpy(vettura_b->colore, dato);
  471.        
  472.         /* Scambio il codice del telaio della vettura */
  473.         strcpy(dato, vettura_a->codice_telaio);
  474.         strcpy(vettura_a->codice_telaio, vettura_b->codice_telaio);
  475.         strcpy(vettura_b->codice_telaio, dato);
  476.        
  477.         /* Scambio il prezzo della vettura */
  478.         prezzo = vettura_a->prezzo;
  479.         vettura_a->prezzo= vettura_b->prezzo;
  480.         vettura_b->prezzo = prezzo;
  481. }
  482.  
  483. /* Definizione della funzione media_prezzi */
  484. void media_prezzi(automobile_t *lista)
  485. {
  486.         double media = 0;
  487.         int numero_auto = conta_automobili(lista);
  488.         int somma = somma_prezzi(lista);
  489.  
  490.         media = (double)somma / numero_auto;
  491.        
  492.         printf("\nLa media dei prezzi e' %.2lf\n" , media);
  493.        
  494.         printf("\n");
  495. }
  496.  
  497. /* Definizione della funzione mediana_prezzi */
  498. void mediana_prezzi(automobile_t *lista)
  499. {
  500.         automobile_t *auto_1, *auto_2;
  501.         double mediana = 0;
  502.         int indice_auto_1;
  503.         int indice_auto_2;
  504.         int numero_auto = conta_automobili(lista);
  505.        
  506.         indice_auto_1 = (numero_auto - 1) / 2;
  507.         indice_auto_2 = numero_auto / 2;
  508.        
  509.         quicksort_prezzo(lista, 0 , numero_auto - 1);
  510.        
  511.         auto_1 = posizione_vettura(lista, indice_auto_1);
  512.         auto_2 = posizione_vettura(lista, indice_auto_2);
  513.        
  514.         mediana = (auto_1->prezzo + auto_2->prezzo) / 2;
  515.        
  516.         printf("La mediana dei prezzi vale %.2lf\n", mediana);
  517.         printf("\n");
  518. }
  519.  
  520. /* Definizione della funzione stampa_lista */
  521. void stampa_lista(automobile_t *lista)
  522. {
  523.         int i = 1;
  524.         automobile_t *p = lista;
  525.        
  526.         while (!(p == NULL))
  527.         {
  528.                 printf("%d\t%s\t%s\t%s\t%s\t%d\n", i, p->marca, p->modello, p->colore, p->codice_telaio, p->prezzo);
  529.                 p = p->vettura_succ;
  530.                 i++;
  531.         }
  532.        
  533.         printf("\n%d automobili inserite!\n", conta_automobili(lista));
  534.         printf("\n");
  535. }
  536.  
  537. /* Definizione della funzione conta_automobili */
  538. int conta_automobili(automobile_t *testa)
  539. {
  540.         automobile_t* temp = testa;                     /* Lavoro = Variabile temp di tipo struttura dati */
  541.         int n_auto = 1;                                         /* Output = Numero di automobili nella lista */
  542.  
  543.         if (temp == NULL)
  544.         {
  545.                 return 0;
  546.         }
  547.                
  548.         while(temp->vettura_succ != NULL)
  549.         {
  550.                 n_auto++;
  551.                 temp = temp->vettura_succ;
  552.         }
  553.        
  554.         return n_auto;
  555. }
  556.  
  557. /* Definizione della funzione somma_prezzi */
  558. int somma_prezzi(automobile_t *testa)
  559. {
  560.         automobile_t *temp = testa;
  561.         int somma = 0;
  562.  
  563.         if(temp == NULL)
  564.         {
  565.                 return 0;
  566.         }
  567.        
  568.         while (temp->vettura_succ != NULL)
  569.         {
  570.                 somma = somma + temp->prezzo;
  571.                 temp = temp->vettura_succ;
  572.         }
  573.        
  574.         return somma;
  575. }
  576.  
  577. /* Definizione della funzione posizione vettura */
  578. automobile_t *posizione_vettura(automobile_t *testa, int posizione)
  579. {
  580.         automobile_t *temp = testa;
  581.         int i = 0;
  582.        
  583.         for(i = 0 ; i < posizione; i++)
  584.         {
  585.                 temp = temp->vettura_succ;
  586.         }
  587.        
  588.         return temp;
  589. }
  590.  
  591. /* Definizione della funzione quicksort_marca */
  592. void quicksort_marca(automobile_t *list, int indice_sx, int indice_dx)
  593. {
  594.         automobile_t *lista = list;
  595.         int pivot_index;
  596.        
  597.         /* Controllo per la chiamata ricorsiva di quicksort_marca */
  598.         if (indice_sx < indice_dx)
  599.         {
  600.                 pivot_index = ripartizione_marca(lista, indice_sx, indice_dx);
  601.             quicksort_marca(lista, indice_sx, pivot_index - 1);
  602.                 quicksort_marca(lista, pivot_index + 1,indice_dx);
  603.         }
  604. }
  605.  
  606. /* Definizione della funzione ripartizione_marca */
  607. int ripartizione_marca(automobile_t *prima_vettura, int indice_sx, int indice_dx)
  608. {
  609.         int i, j;
  610.         automobile_t *pivot = posizione_vettura(prima_vettura, indice_sx);
  611.  
  612.         i = indice_sx;
  613.         j = indice_dx;
  614.         automobile_t *auto_da_sx = posizione_vettura(prima_vettura, i);
  615.         automobile_t *auto_da_dx = posizione_vettura(prima_vettura, j);
  616.        
  617.         while (i < j)
  618.         {
  619.                
  620.                 while(strcmp(auto_da_sx->marca, pivot->marca) < 0 && i < indice_dx)
  621.                 {      
  622.                         i++;
  623.                         auto_da_sx = auto_da_sx->vettura_succ;
  624.                 }
  625.                
  626.                 while(strcmp(auto_da_dx->marca, pivot->marca) > 0)
  627.                 {
  628.                         auto_da_dx = auto_da_dx->vettura_prec;
  629.                         j--;
  630.                 }
  631.  
  632.                 if (i < j)
  633.                 {
  634.                         scambia(auto_da_sx, auto_da_dx);
  635.                 }
  636.  
  637.         }
  638.        
  639.         scambia(auto_da_sx, auto_da_dx);
  640.         return j;
  641. }
  642.  
  643. /* Definizione della funzione quicksort_modello */
  644. void quicksort_modello(automobile_t *list, int indice_sx, int indice_dx)
  645. {
  646.         automobile_t *lista = list;
  647.         int pivot_index;
  648.        
  649.         /* Controllo per la chiamata ricorsiva alla quicksort_modello */
  650.         if (indice_sx < indice_dx)
  651.         {
  652.                 pivot_index = ripartizione_modello(lista, indice_sx, indice_dx);
  653.             quicksort_modello(lista, indice_sx, pivot_index - 1);
  654.                 quicksort_modello(lista, pivot_index + 1,indice_dx);
  655.         }
  656. }
  657.  
  658. /* Definizione della funzione ripartizione_marca */
  659. int ripartizione_modello(automobile_t *prima_vettura, int indice_sx, int indice_dx)
  660. {
  661.         int i, j;
  662.         automobile_t * pivot = posizione_vettura(prima_vettura, indice_sx);
  663.  
  664.         i = indice_sx;
  665.         j = indice_dx;
  666.         automobile_t *auto_da_sx = posizione_vettura(prima_vettura, i);
  667.         automobile_t *auto_da_dx = posizione_vettura(prima_vettura, j);
  668.        
  669.         while (i < j)
  670.         {
  671.                
  672.                 while(strcmp(auto_da_sx->modello, pivot->modello) < 0 && i < indice_dx)
  673.                 {      
  674.                         i++;
  675.                         auto_da_sx = auto_da_sx->vettura_succ;
  676.                 }
  677.                
  678.                 while(strcmp(auto_da_dx->modello, pivot->modello) > 0)
  679.                 {
  680.                         auto_da_dx = auto_da_dx->vettura_prec;
  681.                         j--;
  682.                 }
  683.  
  684.                 if (i < j)
  685.                 {
  686.                         scambia(auto_da_sx, auto_da_dx);
  687.                 }
  688.  
  689.         }
  690.        
  691.         scambia(auto_da_sx, auto_da_dx);
  692.        
  693.         return j;
  694. }
  695.  
  696. /* Definizione della funzione quicksort_colore*/
  697. void quicksort_colore(automobile_t *list, int indice_sx, int indice_dx)
  698. {
  699.         automobile_t *lista = list;
  700.         int pivot_index;
  701.        
  702.         /* Controllo per la chiamata ricorsiva alla quicksort_colore */
  703.         if (indice_sx < indice_dx)
  704.         {
  705.                 pivot_index = ripartizione_colore(lista, indice_sx, indice_dx);
  706.             quicksort_colore(lista, indice_sx, pivot_index - 1);
  707.                 quicksort_colore(lista, pivot_index + 1,indice_dx);
  708.         }
  709. }
  710.  
  711. /* Definizione della funzione ripartizione_marca */
  712. int ripartizione_colore(automobile_t *prima_vettura, int indice_sx, int indice_dx)
  713. {
  714.         int i, j;
  715.         automobile_t *pivot = posizione_vettura(prima_vettura, indice_sx);
  716.  
  717.         i = indice_sx;
  718.         j = indice_dx;
  719.         automobile_t *auto_da_sx = posizione_vettura(prima_vettura, i);
  720.         automobile_t *auto_da_dx = posizione_vettura(prima_vettura, j);
  721.        
  722.         while (i < j)
  723.         {
  724.                
  725.                 while(strcmp(auto_da_sx->colore, pivot->colore) < 0 && i < indice_dx)
  726.                 {      
  727.                         i++;
  728.                         auto_da_sx = auto_da_sx->vettura_succ;
  729.                 }
  730.                
  731.                 while(strcmp(auto_da_dx->colore, pivot->colore) > 0)
  732.                 {
  733.                         auto_da_dx = auto_da_dx->vettura_prec;
  734.                         j--;
  735.                 }
  736.  
  737.                 if (i < j)
  738.                 {
  739.                         scambia(auto_da_sx, auto_da_dx);
  740.                 }
  741.  
  742.         }
  743.        
  744.         scambia(auto_da_sx, auto_da_dx);
  745.        
  746.         return j;
  747. }
  748.  
  749. /* Definizione della funzione quicksort_codice_telaio */
  750. void quicksort_codice_telaio(automobile_t *list, int indice_sx, int indice_dx)
  751. {
  752.         automobile_t *lista = list;
  753.         int pivot_index;
  754.        
  755.         /* Controllo per la chiamata ricorsiva alla quicksort_codice_telaio */
  756.         if (indice_sx < indice_dx)
  757.         {
  758.                 pivot_index = ripartizione_codice_telaio(lista, indice_sx, indice_dx);
  759.             quicksort_codice_telaio(lista, indice_sx, pivot_index - 1);
  760.                 quicksort_codice_telaio(lista, pivot_index + 1,indice_dx);
  761.         }
  762. }
  763.  
  764. /* Definizione della funzione ripartizione_codice_telaio */
  765. int ripartizione_codice_telaio(automobile_t *prima_vettura, int indice_sx, int indice_dx)
  766. {
  767.         int i, j;
  768.         automobile_t *pivot = posizione_vettura(prima_vettura, indice_sx);
  769.  
  770.         i = indice_sx;
  771.         j = indice_dx;
  772.         automobile_t *auto_da_sx = posizione_vettura(prima_vettura, i);
  773.         automobile_t *auto_da_dx = posizione_vettura(prima_vettura, j);
  774.        
  775.         while (i < j)
  776.         {
  777.                
  778.                 while(strcmp(auto_da_sx->codice_telaio, pivot->codice_telaio) < 0 && i < indice_dx)
  779.                 {      
  780.                         i++;
  781.                         auto_da_sx = auto_da_sx->vettura_succ;
  782.                 }
  783.                
  784.                 while(strcmp(auto_da_dx->codice_telaio, pivot->codice_telaio) > 0)
  785.                 {
  786.                         auto_da_dx = auto_da_dx->vettura_prec;
  787.                         j--;
  788.                 }
  789.  
  790.                 if (i < j)
  791.                 {
  792.                         scambia(auto_da_sx, auto_da_dx);
  793.                 }
  794.  
  795.         }
  796.        
  797.         scambia(auto_da_sx, auto_da_dx);
  798.         return j;
  799. }
  800.  
  801. /* Definizione della funzione quicksort_prezzo */
  802. void quicksort_prezzo(automobile_t *list, int indice_sx, int indice_dx)
  803. {
  804.         automobile_t *lista = list;
  805.         int pivot_index;
  806.        
  807.         /* Controllo per la chiamata ricorsiva alla quicksort_prezzo */
  808.         if (indice_sx < indice_dx)
  809.         {
  810.                 pivot_index = ripartizione_prezzo(lista, indice_sx, indice_dx);
  811.             quicksort_prezzo(lista, indice_sx, pivot_index - 1);
  812.                 quicksort_prezzo(lista, pivot_index + 1, indice_dx);
  813.         }
  814. }
  815.  
  816. /* Definizione della funzione ripartizione_prezzo */
  817. int ripartizione_prezzo(automobile_t *prima_vettura, int indice_sx, int indice_dx)
  818. {
  819.         int i, j;
  820.         automobile_t *pivot = posizione_vettura(prima_vettura,indice_sx);
  821.  
  822.         i = indice_sx;
  823.         j = indice_dx;
  824.         automobile_t *auto_da_sx = posizione_vettura(prima_vettura,i);
  825.         automobile_t *auto_da_dx = posizione_vettura(prima_vettura,j);
  826.        
  827.         while (i < j)
  828.         {
  829.                
  830.                 while(auto_da_sx->prezzo < pivot->prezzo && i < indice_dx)
  831.                 {      
  832.                         i++;
  833.                         auto_da_sx = auto_da_sx->vettura_succ;
  834.                 }
  835.                
  836.                 while (auto_da_dx->prezzo > pivot->prezzo)
  837.                 {
  838.                         auto_da_dx = auto_da_dx->vettura_prec;
  839.                         j--;
  840.                 }
  841.  
  842.                 if (i < j)
  843.                 {
  844.                         scambia(auto_da_sx,auto_da_dx);
  845.                 }
  846.  
  847.         }
  848.        
  849.         scambia(auto_da_sx,auto_da_dx);
  850.        
  851.         return j;
  852. }
  853.  
  854. /* Definizione della funzione valutazione_sperimentale */
  855. void valutazione_sperimenta(automobile_t *lista, int n)
  856. {
  857.        
  858.        
  859.        
  860.        
  861.        
  862.        
  863.        
  864.        
  865.        
  866.        
  867.        
  868.        
  869.        
  870.        
  871. }



L'ultima funzione sto cercando in tutti i modi di progettarla ma ancora senza risultato quindi per ora la potete ignorare.
Grazie 1000 a tutti per il vostro aiuto ;) ;)

In Allegato il file di testo con le automobili.

Luca

PM
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6230
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 19:59
Giovedė, 18/06/2015
Apri un nuovo topic.


Il mio blog: https://piero.dev
PM
Pagine: [ 1 2 3 4 5 ] Precedente | Prossimo