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++ - Ordinamento Quicksort
Forum - C/C++ - Ordinamento Quicksort

Pagine: [ 1 2 3 ] Precedente | Prossimo
Avatar
luca260786 (Normal User)
Rookie


Messaggi: 21
Iscritto: 10/01/2008

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



Grazie 1000 a tutti per l'aiuto.


luca260786 ha allegato un file: automobili.zip (305 bytes)
Clicca qui per scaricare il file

Ultima modifica effettuata da luca260786 il 19/06/2015 alle 22:40


La Programmazione è fondamentale per uno studente di Informatica.
PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6108
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 15:54
Venerdì, 19/06/2015
Così ad occhio:

Codice sorgente - presumibilmente Plain Text

  1. while(strcmp(auto_da_dx->codice_telaio, pivot->codice_telaio) > 0)



Manca un && j >= 0.

Attacca un debugger al tuo programma (trova istruzioni su come farlo per il tuo IDE con Google), esegui il programma passo per passo e identifica dov'è il loop infinito.



Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
Ultimo (Member)
Expert


Messaggi: 513
Iscritto: 22/05/2010

Segnala al moderatore
Postato alle 16:19
Venerdì, 19/06/2015
manca il file txt con le auto, manca la possibilità di salvare in un file l'elenco delle auto, se va in loop è probabile un errore logico

p.s. non ho visto la risposta di Piero ;)

p.p.s. troppe funzioni ripetitive

Ultima modifica effettuata da Ultimo il 19/06/2015 alle 16:27


Ultimo (Hai voluto la bicicletta ? ....)

Studiare LINQ, WPF, ASP.NET MVC, Entity Framwork, C#, Blend, XAML, Javascript, HTML5, CSS .....(tanta roba)

https://www.dropbox.com/s/c2aots5x4urgbhf/setup_game_sudoku ...
PM Quote
Avatar
luca260786 (Normal User)
Rookie


Messaggi: 21
Iscritto: 10/01/2008

Segnala al moderatore
Postato alle 23:54
Venerdì, 19/06/2015
Buonasera a tutti grazie per il vostro aiuto e per la segnalazione ho messo il file delle automobili ho provato come suggerito ma niente va in loop. Uso Dev e con il debug non riesco a capire dove va in loop con tutte le chiamate ricorsive che fa. Suggerimenti? Grazie 1000.


La Programmazione è fondamentale per uno studente di Informatica.
PM Quote
Avatar
Ultimo (Member)
Expert


Messaggi: 513
Iscritto: 22/05/2010

Segnala al moderatore
Postato alle 13:22
Sabato, 20/06/2015
ho provato gli ordinamenti e funzionano

se inserisci una nuova auto è probabile che non venga aggiornato il numero degli elementi e quindi va in loop


Ultimo (Hai voluto la bicicletta ? ....)

Studiare LINQ, WPF, ASP.NET MVC, Entity Framwork, C#, Blend, XAML, Javascript, HTML5, CSS .....(tanta roba)

https://www.dropbox.com/s/c2aots5x4urgbhf/setup_game_sudoku ...
PM Quote
Avatar
luca260786 (Normal User)
Rookie


Messaggi: 21
Iscritto: 10/01/2008

Segnala al moderatore
Postato alle 13:59
Sabato, 20/06/2015
Testo quotato

Postato originariamente da Ultimo:

ho provato gli ordinamenti e funzionano

se inserisci una nuova auto è probabile che non venga aggiornato il numero degli elementi e quindi va in loop



Buongiorno si funzionano se inserisci auto diverse, ma se inserisci un'auto identica va in loop infinito come ho scritto nel primo post.


La Programmazione è fondamentale per uno studente di Informatica.
PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6108
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 16:04
Sabato, 20/06/2015
Testo quotato

Postato originariamente da luca260786:
Uso Dev e con il debug non riesco a capire dove va in loop con tutte le chiamate ricorsive che fa. Suggerimenti?



Metti un count/printf all'interno di ogni loop (con una stringa diversa per ogni loop) e guarda qual'è quello che va avanti all'infinito.


Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
luca260786 (Normal User)
Rookie


Messaggi: 21
Iscritto: 10/01/2008

Segnala al moderatore
Postato alle 15:06
Domenica, 21/06/2015
Testo quotato

Postato originariamente da pierotofy:

Testo quotato

Postato originariamente da luca260786:
Uso Dev e con il debug non riesco a capire dove va in loop con tutte le chiamate ricorsive che fa. Suggerimenti?



Metti un count/printf all'interno di ogni loop (con una stringa diversa per ogni loop) e guarda qual'è quello che va avanti all'infinito.




Buongiorno Piero puoi dirmi in quale parte del codice mettere il count? Grazie per l'aiuto


La Programmazione è fondamentale per uno studente di Informatica.
PM Quote
Avatar
Ultimo (Member)
Expert


Messaggi: 513
Iscritto: 22/05/2010

Segnala al moderatore
Postato alle 17:37
Domenica, 21/06/2015
i quicksort erano errati, guarda se ti funziona

Codice sorgente - presumibilmente Plain Text

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



Ultimo (Hai voluto la bicicletta ? ....)

Studiare LINQ, WPF, ASP.NET MVC, Entity Framwork, C#, Blend, XAML, Javascript, HTML5, CSS .....(tanta roba)

https://www.dropbox.com/s/c2aots5x4urgbhf/setup_game_sudoku ...
PM Quote
Pagine: [ 1 2 3 ] Precedente | Prossimo