#include <stdio.h>
#include <stdlib.h>
int compare_int(const void * a, const void * b){   
   return (*(int*)a) - (*(int*)b);
}

int main (int argc, char **argv)
{   /*Dichiarazioni*/   
   struct _record
   {
      int id;
      char nome[30];
   } record [] =
   {
       {1, "pippo"}
      ,{5, "topolino"}
      ,{2, "pluto"}
      ,{0, "minnie"}      
   };                                              /*array di record di esempio da trovare*/
   
   size_t elem_size = sizeof(struct _record);      /* dimensione di un record */   
   size_t elem_count = sizeof(record) / elem_size; /* quanti record nell'array */   
   int * indice;                                   /* indice */   
   int i;                                          /* contatore */   
   int find;                                       /* elemento da trovare */
   int *trovato;                                   /* elemento trovato */

   /* Implementazione */      
   
   indice = (int*)malloc(sizeof(int)*elem_count);  /*1) Allocazione memoria */   
   if(indice==NULL) return 1;

   for(i=0;i<elem_count;++i)                       /*2) riempimento indice */
      indice[i] = record[i].id;   
   
   qsort(indice, elem_count, sizeof(int), compare_int); /*3) Ordinamento indice*/   
   
   find = 2;                                       /*4) cerco il record con id = 2 */    
   trovato = (int*)bsearch(&find, indice, elem_count, sizeof(int), compare_int);
      
   if(trovato != NULL)                             /*5) stampa risultato */
      printf("Record trovato:nID: %d nNome: %sn", record[*trovato].id, record[*trovato].nome);
   else
      printf("Non trovaton");
   
   free(indice);                                   /*6) liberazione memoria allocata */
}

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int valore_chiave;
    int indice;
}index;


int compare_index (const void* a, const void* b)
{
    return ((index*)a)->valore_chiave - ((index*)b)->valore_chiave;
}


int main (int argc, char **argv)
{   /*Dichiarazioni*/   
    struct _record
    {
        int id;
        char nome[30];
    } record [] =
    {
        {1, "pippo"}
        ,{5, "topolino"}
        ,{2, "pluto"}
        ,{0, "minnie"}      
    };                                              /*array di record di esempio da trovare*/
    
    size_t elem_size = sizeof(struct _record);      /* dimensione di un record */   
    size_t elem_count = sizeof(record) / elem_size; /* quanti record nell'array */ 
    index* indice;
    int i;                                          /* contatore */   
    index find;                                       /* elemento da trovare */
    index *trovato;                                   /* elemento trovato */
    
    /* Implementazione */      
    
    indice = (index*)malloc(sizeof(index)*elem_count);  /*1) Allocazione memoria */  
    if(indice==NULL) return 1;
    
    for(i=0;i<elem_count;++i)                       /*2) riempimento indice */
    {
        indice[i].valore_chiave = record[i].id;  
        indice[i].indice=i;
    }
    
    qsort(indice, elem_count, sizeof(index), compare_index); /*3) Ordinamento indice*/   
    
    find.valore_chiave=5;                                          
    trovato = bsearch(&find, indice, elem_count, sizeof(index), compare_index);
    
    if(trovato != NULL)                             /*5) stampa risultato */
        printf("Record trovato:nID: %d nNome: %s", record[trovato->indice].id,record[trovato->indice].nome);
    else
        printf("Non trovato");
    
    free(indice);                                   /*6) liberazione memoria allocata */
}

#include <stdlib.h>
#include "indice.h"
/* IMPLEMENTAZIONE INDICE */

struct _indice
{
   void* chiave;
   void* puntatore;
};


struct _indice * creaindice(void * v, size_t element_size, size_t l, void*(*key_selector)(void*), int(*comparer)(const void*, const void*))
{
   size_t i;
   struct _indice * pindex = (struct _indice *)malloc(sizeof(struct _indice)*l);

   if(pindex==NULL)return NULL;

   for(i = 0; i<l;++i)
   {
      pindex[i].chiave = (void*)key_selector(v);
      pindex[i].puntatore = v;
      v = (void*)((char*)v + element_size);
   }
   qsort (pindex, l, sizeof(struct _indice), comparer);

   return pindex;
}

void * sfogliaindice(struct _indice * indice, size_t len, void * key, int(*comparer)(const void*, const void*))
{
   struct _indice elem;   /*elemento da cercare nell'indice*/
   struct _indice * pItem;

   elem.chiave = key;
   elem.puntatore = NULL;
   
   pItem = (struct _indice *) bsearch (&elem, indice, len, sizeof (struct _indice), comparer);

   if(pItem == NULL) return NULL;
   return pItem->puntatore;
}