SHARE
TWEET

Untitled

a guest Nov 13th, 2019 73 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <string.h>
  3. #define MAXR 31
  4. #define LINE 300
  5. #define MAXN 1000
  6.  
  7. typedef struct {
  8.     int a;
  9.     int m;
  10.     int g;
  11. } data_t;
  12.  
  13. typedef struct {
  14.     int h;
  15.     int m;
  16.     int s;
  17. } ora_t;
  18.  
  19. typedef struct {
  20.     char codice_tratta[MAXR];
  21.     char partenza[MAXR];
  22.     char destinazione[MAXR];
  23.     char data_stringa[MAXR];
  24.     char ora_partenza[MAXR];
  25.     char ora_arrivo[MAXR];
  26.     int ritardo;
  27.     data_t data;
  28.     ora_t hpartenza, harrivo;
  29. } tabella;
  30.  
  31.  
  32. void leggitab(tabella *tab, int *dim);
  33. void opzioni(int *opz, tabella *tab, int *dim);
  34. void stampaLog(tabella **tab, int *dim);
  35. //FUNZIONI DI CONFRONTO TRA ITEMS.
  36. int ITEMlt(tabella *p, tabella *x, int caso);
  37. int confrontaorari (tabella *p, tabella *x);
  38. //FUNZIONE DI ORDINAMENTO.
  39. void insertionSort(tabella **p, int l, int r, int *opz);
  40. void ricerca(tabella **p, tabella *k, int *dim, int state);
  41. void ricercaLin(tabella **p, int l, int r, tabella k);
  42. void ricercaBin(tabella **p, int l, int r, tabella k);
  43.  
  44.  
  45. int main(int argc, const char * argv[]) {
  46.    
  47.     tabella tab[MAXN];
  48.     int dim, opzione;
  49.    
  50.     leggitab(tab, &dim);
  51.     opzioni(&opzione, tab, &dim);
  52.    
  53.     return 0;
  54. }
  55.  
  56. void leggitab(tabella *tab, int *dim) {
  57.     char sinput[LINE];
  58.     FILE *fp;
  59.     int i;
  60.    
  61.     fp = fopen("log.txt", "r");
  62.     if (fp == NULL){
  63.         printf("errore apertura file.\n");
  64.         return;
  65.     }
  66.     fscanf(fp, "%d\n", dim);
  67.     for (i = 0; i < *dim; i++) {
  68.         fgets (sinput, LINE, fp);
  69.         sscanf(sinput, "%s %s %s %s %s %s %d", tab[i].codice_tratta, tab[i].partenza, tab[i].destinazione, tab[i].data_stringa, tab[i].ora_partenza, tab[i].ora_arrivo, &tab[i].ritardo );
  70.         sscanf (tab[i].data_stringa,"%d/%d/%d", &tab[i].data.a,&tab[i].data.m,&tab[i].data.g);
  71.         sscanf (tab[i].ora_partenza,"%d:%d:%d", &tab[i].hpartenza.h,&tab[i].hpartenza.m,&tab[i].hpartenza.s);
  72.         sscanf (tab[i].ora_arrivo,"%d:%d:%d", &tab[i].harrivo.h,&tab[i].harrivo.m,&tab[i].harrivo.s);
  73.     }
  74.     fclose(fp);
  75.    
  76.     return;
  77. }
  78.  
  79. void stampaLog(tabella **tab, int *dim) {
  80.     int i;
  81.     printf("il log è:\n");
  82.     for (i = 0; i < *dim; i++) {
  83.         printf("%s %s %s %s %s %s %d\n", tab[i]->codice_tratta, tab[i]->partenza, tab[i]->destinazione, tab[i]->data_stringa, tab[i]->ora_partenza, tab[i]->ora_arrivo, tab[i]->ritardo);
  84.     }
  85.     return;
  86. }
  87.  
  88. void opzioni(int *opz, tabella *tab, int *dim) {
  89.    
  90.     tabella *tab2[*dim];
  91.     int status = 0, i;
  92.    
  93.     for(i = 0; i < *dim; i++) {
  94.         tab2[i] = &tab[i];
  95.     }
  96.    
  97.     //RENDERE LO SWITCH ITERATTIVO.
  98.     while (1) {
  99.        
  100.         printf("schiaccia 1 per stampare il log\n");
  101.         printf("schiaccia 2 per ordinare per data\n");
  102.         printf("schiaccia 3 per ordinare per codice di tratta\n");
  103.         printf("schiaccia 4 per ordinare per stazione di partenza\n");
  104.         printf("schiaccia 5 per ordinare per stazione di arrivo\n");
  105.         printf("schiaccia 6 per ricercare una stazione di partenza\n"); //dicotomica o lineare.
  106.         scanf("%d", opz);
  107.        
  108.         switch (*opz) {
  109.             case 1:
  110.                 stampaLog(tab2, dim);
  111.                 break;
  112.             case 2:
  113.                 insertionSort(tab2, 0, *dim-1, opz);
  114.                 break;
  115.             case 3:
  116.                insertionSort(tab2, 0, *dim-1, opz);
  117.                 break;
  118.             case 4:
  119.                insertionSort(tab2, 0, *dim-1, opz);
  120.                 status = 1;
  121.                 break;
  122.             case 5:
  123.                 insertionSort(tab2, 0, *dim-1, opz);
  124.                 break;
  125.             case 6:
  126.                 ricerca(tab2, tab, dim, status);
  127.                 break;
  128.             default:
  129.                 return;
  130.                 break;
  131.                
  132.         }
  133.        
  134.     }
  135.     return;
  136. }
  137.  
  138. void ricerca(tabella **p, tabella *k, int *dim, int state){
  139.     int l = 0, r = *dim-1;
  140.     tabella chiave;
  141.     printf("inserisci la chiave:\n");
  142.     scanf("%s", chiave.partenza);
  143.     if (state == 0) //TABELLA NON ORDINATA.
  144.         ricercaLin(p, l, r, chiave);
  145.     else  //STATE == 1 E QUINDI TABELLA ORDINATA.
  146.         ricercaBin(p, l, r, chiave);
  147.     return;
  148. }
  149.  
  150. void ricercaLin(tabella **p, int l, int r, tabella k) {
  151.     int i = l;
  152.     int n = (int)strlen(k.partenza);
  153.    
  154.     while(i <= r ) {
  155.         if (strncmp(k.partenza, p[i]->partenza, n) == 0)
  156.             printf("%s %s %s %s %s %s %d\n", p[i]->codice_tratta, p[i]->partenza,p[i]->destinazione, p[i]->data_stringa, p[i]->ora_partenza, p[i]->ora_arrivo, p[i]->ritardo);
  157.         else i++;
  158.     }
  159.     return;
  160. }
  161.  
  162. void ricercaBin(tabella **p, int l, int r, tabella k) {
  163.     int m = 0;
  164.     int n = (int)strlen(k.partenza);
  165.     while (l <= r) {
  166.         m = (l+r)/2;
  167.        if (strncmp(k.partenza, p[m]->partenza, n) == 0)
  168.             printf("%s %s %s %s %s %s %d\n", p[m]->codice_tratta, p[m]->partenza,p[m]->destinazione, p[m]->data_stringa, p[m]->ora_partenza, p[m]->ora_arrivo, p[m]->ritardo);
  169.         if(strncmp(p[m]->partenza, k.partenza, n) < 0)
  170.             l = m+1;
  171.         else
  172.             r = m-1;
  173.     }
  174.     return;
  175. }
  176.  
  177.  
  178. int ITEMlt(tabella *p, tabella *x, int caso) {
  179.    
  180.     switch(caso) {
  181.         case 2: //CASO DATA.
  182.             return confrontaorari(p,x);
  183.             break;
  184.         case 3: //CASO CODICE DI TRATTA.
  185.             return (strcmp(x->codice_tratta, p->codice_tratta));
  186.             break;
  187.         case 4: //CASO STAZIONE DI PARTENZA.
  188.             return(strcmp(x->partenza, p->partenza));
  189.             break;
  190.         case 5: //CASO STAZIONE DI ARRIVO.
  191.             return(strcmp(x->destinazione, p->destinazione));
  192.             break;
  193.     }
  194.    
  195.     return -1;
  196. }
  197.  
  198. void insertionSort(tabella **p, int l, int r, int *opz) {
  199.     int i, j = 0;
  200.     tabella *x = NULL;
  201.    
  202.     for (i = l; i <= r; i++) {
  203.         x = p[i];
  204.         j = i-1;
  205.         while(j >= l && ITEMlt(p[j], x, *opz) < 0) {
  206.             p[j+1] = p[j]; //SCAMBIO GLI INDIRIZZI.
  207.             j--;
  208.         }
  209.         p[j+1] = x;
  210.     }
  211.     return;
  212. }
  213.  
  214. int confrontaorari (tabella *p, tabella *x) {
  215.     if (x->data.a < p->data.a)
  216.         return -1;
  217.     else if (x->data.a == p->data.a) {
  218.         if(x->data.m < p->data.m)
  219.             return -1;
  220.         else if(x->data.m == p->data.m) {
  221.             if (x->data.g < p->data.g)
  222.                 return -1;
  223.             else if (x->data.g == p->data.g) {
  224.                 if (x->hpartenza.h < p->hpartenza.h)
  225.                     return -1;
  226.                 else if (x->hpartenza.h == p->hpartenza.h) {
  227.                     if(x->hpartenza.m < p->hpartenza.m)
  228.                         return -1;
  229.                     else if (x->hpartenza.m == p->hpartenza.m){
  230.                         if(x->hpartenza.s < p->hpartenza.s)
  231.                             return -1;
  232.                         else if(x->hpartenza.s == p->hpartenza.s)
  233.                             return -1;
  234.                     }
  235.                     return 0;
  236.                 }
  237.                 return 0;
  238.                
  239.             }
  240.             return 0;
  241.         }
  242.         return 0; //la data di x è maggiore della data di p.
  243.     }
  244.    
  245.     return 0; //la data di x è maggiore della data di p.
  246.    
  247.    
  248. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top