Sei sulla pagina 1di 11

#include <stdbool.h> #include <stdio.h>

#define ARRAY_MAX (10)

#include <stdio.h> #define ARRAY_MAX (10) TInfo temp=*a; *a=*b; *b=temp; Ricerca la posizione del

TInfo temp=*a;

*a=*b;

*b=temp;

Ricerca la posizione del minimo in un array.

typedef int TInfo; /* definizione tipo elemento array di interi */

bool less(TInfo a, TInfo b)

{

return a < b;

}

/*

*

variabile di appoggio temp) */

void swap(TInfo *a, TInfo *b)

{

}

/*

* PRE: n>0

/* ritorna true se a precede b / false per a uguale o superiore a b */

Scambia i valori di due informazioni

(lavorando con i puntatori all'indirizzo in memoria in cui tali valori risiedono e con una

* la funzione memorizza la posizione del minimo parziale che, a fine iterazione, è il minimo dell'intero array */ int search_min(TInfo a[], int n)

{

int i, imin;

imin=0;

for(i=1; i<n; i++) if (less(a[i], a[imin])) imin=i; return imin;

}

/* Ordina l'array a con l'algoritmo di ordinamento per selezione

*/

void selection_sort(TInfo a[], int n)

{

int i, imin; for (i=0; i<n-1; i++) // bastano n-1 iterazioni - l'ultimo elemento trovato è minimo di se

stesso

{

/* alla funzione search_min non passo l'intero vettore, ma:

 

*

- il puntatore all'elemento i -> il primo elemento della parte non ancora ordinata

*

- il numero n-i di elementi della parte non ancora ordinata

*

dalla funzione search_min ricevo la posizione del minimo all'interno della porzione

di

array trasmessa

*

tale posizione va sommata ad i (numero di elementi della parte già ordinata)

*

per ottenere l'indice del minimo rispetto all'intero array

*/ imin=i+search_min(a+i, n-i); if (imin!=i) // effettuo uno scambio di posizione in memoria tra l'ultimo minimo trovato a [imin] ed il primo elemento successivo alla parte già ordinata a[i], a meno che già non coindano swap(&a[i], &a[imin]);

}

printf("\n\n array ordinato con SELECTION SORT : "); for (i=0; i<n; i++)

{

printf("%d ", a[i]);

}

printf("\n\n");

}

int main()

{

/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */ int cont; TInfo vet[ARRAY_MAX];

vet[0]=12;

vet[1]=1;

vet[2]=8;

vet[3]=17;

vet[4]=25; vet[5]=3; vet[6]=44; vet[7]=12; vet[8]=9; vet[9]=30; printf(" array originario : "); for
vet[4]=25;
vet[5]=3;
vet[6]=44;
vet[7]=12;
vet[8]=9;
vet[9]=30;
printf(" array originario : ");
for (cont=0; cont<ARRAY_MAX; cont++)
{
printf("%d ", vet[cont]);
}
selection_sort(vet, ARRAY_MAX);

}

#include <stdbool.h> #include <stdio.h>

#define ARRAY_MAX (10)

typedef int TInfo; /* definizione tipo elemento array di interi */

bool greater(TInfo a, TInfo b)

{

return a > b;

}

/* ritorna true se a segue (è più grande di) b */

/* Scambia i valori di due informazioni

* (lavorando con i puntatori all'indirizzo in memoria in cui tali valori risiedono e con una variabile di appoggio temp) */ void swap(TInfo *a, TInfo *b)

{

TInfo temp=*a;

*a=*b;

*b=temp;

}

/* Ordinamento a bolle */

void bubble_sort(TInfo a[], int n)

{

int i, k; bool modified;

modified=true; // l'inizializzazione a true serve a far eseguire la prima iterazione (anche se l'array di fatto non è stato ancora modificato) /* il ciclo esterno gestisce le scansioni da effettuare con k numero di scansioni completate * termina :

* - al raggiungimento del numero massimo di scansioni k==n-1

*

-

O

* - se l'ultima scansione non ha modificato l'array (modified=false) ovvero non ci sono state sostituzioni swap */

for (k=0; k<n-1 && modified; k++)

{

modified=false; // inizializzo modified a false ad inizio ciclo (non è ancora stata eseguita alcuna scansione) /* il ciclo interno esamina tutte le coppie di elementi adiacenti a partire dal primo elemento

a[0]

* è dimostrato che dopo k scansioni, i k elementi più grandi - da a[n-k] ad a[n-1] - sono

ordinati

* quindi il ciclo si ferma quando i raggiunge il valore n-k-1

*/ for(i=0; i<n-k-1; i++)

if (greater(a[i], a[i+1]))

{

// se dal confronto della coppia di valori il primo elemento è più grande del secondo,

li scambio tra loro con la funzione swap swap(&a[i], &a[i+1]); modified=true; // nell'iterazione corrente è stata effettuata almeno una modifica

 
} else { printf("%d ", a[i]); } printf("\n\n"); vet[0]=12; vet[1]=1; vet[2]=8;
}
else
{
printf("%d ", a[i]);
}
printf("\n\n");
vet[0]=12;
vet[1]=1;
vet[2]=8;

vet[3]=17;

if (k==n-1 || !modified) printf("\n\n array ordinato con BUBBLE SORT : ");

printf("\n\n array parziale dopo iterazione %d : ", k+1);

/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */

for (i=0; i<n; i++)

 

}

}

int main()

{

int cont; TInfo vet[ARRAY_MAX];

vet[4]=25;

vet[5]=3;

vet[6]=44;

vet[7]=12;

vet[8]=9;

vet[9]=30;

printf(" array originario : ");

for (cont=0; cont<ARRAY_MAX; cont++)

{

printf("%d ", vet[cont]);

}

bubble_sort(vet, ARRAY_MAX);

}

#include <stdbool.h> #include <stdio.h>

#define ARRAY_MAX (10)

typedef int TInfo; /* definizione tipo elemento array di interi */

bool greater(TInfo a, TInfo b)

/* ritorna true se a segue (è più grande di) b */

{

return a > b;

}

/*

Inserisce un elemento in un array gia' ordinato

*

in modo da mantenere l'ordinamento.

*

PRE: - l'array a e' ordinato secondo la funzione less

*

- l'array e' dimensionato in modo da poter contenere

*

almeno n+1 elementi

*/

void insert_in_order(TInfo a[], int n, TInfo x)

{

int pos, i;

/* Cerca la posizione di inserimento usando una versione iterativa modificata della ricerca lineare :

* partendo dall'ultimo elemento del segmento già ordinato e tornando indietro ad ogni

iterazione

* il ciclo all'indietro termina :

* -- se non ci sono altri elementi da esaminare (pos=0 ovvero la posizione è quella del primo

elemento dell'array - l'ultimo del ciclo)

* -- O

* -- se l'elemento correntemente esaminato a[pos-1] è <= dell'elemento passato x (finchè è più

grande il ciclo continua)

* la variabile pos rappresenta l'indice dell'elemento successivo a quello che stiamo controllando, ma, poichè l'iterazione va all'indietro,

* la posizione di inserimento pos risultante sarà quella immediatamente precedente all'ultimo elemento che sia
*
la posizione di inserimento pos risultante sarà quella immediatamente precedente all'ultimo
elemento che sia risultato > x
*/
for(pos=n; pos>0 && greater(a[pos-1], x); pos--)
printf("\n
--> devo mettere il numero %d al posto del numero %d \n", x, a[pos-1]);
/* prima di inserire l'elemento passato nella posizione individuata pos sposto in avanti tutti
gli elementi da pos in poi
*
a partire dall'ultimo elemento di questo segmento e tornando indietro fino a pos (ecco
perchè il vettore deve avere dimensione n+1) */
for (i=n-1; i>=pos; i--)
a[i+1]=a[i];
/* Inserisce l'elemento passato alla corretta posizione pos, che si è liberata (o è già
occupata dall'elemento stesso)
* [rappresentiamo pos col numero pos+1 affinchè la prima posizione sia indicata da 1 e non da
0] */
printf("\n
--> il numero %d va (o resta) in posizione %d \n", x, pos+1);
a[pos]=x;
if (n<ARRAY_MAX-1)
printf("\n array parziale dopo iterazione %d : ", n);
else
printf("\n array definitivo ordinato con INSERTION SORT : ");
for (i=0; i<ARRAY_MAX; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}

/* Ordinamento per inserimenti successivi */ void insertion_sort(TInfo a[], int n)

{

int i; for(i=1; i<n; i++) // i rappresenta il numero di elementi che compongono la parte già ordinata:

vale 1 alla prima iterazione

{

// (parto dal secondo elemento) ed n a fine ciclo

// come argomenti passiamo ad insert_in_order, oltre all'array // il numero di elementi del segmento di array già ordinato in cui faremo l'inserimento // l'elemento i-esimo - il primo fuori dal segmento ordinato - da confrontare e da mantenere in memoria insert_in_order(a, i, a[i]);

}

}

int main()

{

/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */ int cont; TInfo vet[ARRAY_MAX];

vet[0]=12;

vet[1]=1;

vet[2]=8;

vet[3]=17;

vet[4]=25;

vet[5]=3;

vet[6]=44;

vet[7]=12;

vet[8]=9;

vet[9]=30;

printf(" array originario : ");

for (cont=0; cont<ARRAY_MAX; cont++)

{

printf("%d ", vet[cont]);

}

printf("\n"); insertion_sort(vet, ARRAY_MAX);

}

#include <stdbool.h> #include <stdio.h>

#include <stdbool.h> #include <stdio.h> TInfo temp=*a; *a=*b; *b=temp; #define ARRAY_MAX (10) typedef int

TInfo temp=*a;

*a=*b;

*b=temp;

#define ARRAY_MAX (10)

typedef int TInfo; /* definizione tipo elemento array di interi */

bool less(TInfo a, TInfo b)

{

return a < b;

}

/* ritorna true se a precede (è più piccolo di) b */

/* Scambia i valori di due informazioni

*

(lavorando con i puntatori all'indirizzo in memoria in cui tali valori risiedono e con una variabile di appoggio temp) */ void swap(TInfo *a, TInfo *b)

{

}

/* Suddivide l'array a in tre parti:

* - nella prima ci sono tutti elementi minori del pivot;

* - nella seconda c'e' solo il pivot;

* - nella terza ci sono tutti elementi maggiori o uguali del pivot.

* Come pivot viene scelto il primo elemento dell'array iniziale.

* VALORE DI RITORNO

* L'indice della parte centrale (che contiene il solo pivot)

* PRE

* L'array contiene almeno un elemento */ int partition(TInfo a[], int n)

{

// k è l'indice del primo elemento successivo al sottoarray con valori < del pivot -- inizialmente impostato ad 1 perchè l'elemento 0 è il pivot int i, k=1; for (i=1; i<n; i++) if (less(a[i], a[0])) // se trovo un valore a[i] minore rispetto al pivot [a0] // scambio e lo sposto in a[k] e contemporaneamente incremento k di 1 (gli elementi successivi al sottoarray inferiore partiranno 1 cella + in su) swap(&a[i], &a[k++]);

swap(&a[0], &a[k-1]);

// al termine del ciclo scambio e sposto il pivot nella cella a

[k-1] - l'ultimo degli elementi inferiori al pivot

// NB se non ci sono elementi < pivot -> k

varrà ancora 1 -> il pivot a[0] sarà scambiato con se stesso a[1-1]=a[0] //printf("\n\n elemento pivot : %d \n\n", a[k-1]);

return k-1;

}

/* Ordina un array con il Quick Sort */ void quick_sort(TInfo a[], int n)

{

int k, cont; if (n<2)

// la funzione partition restituisce il nuovo indice del pivot

// Caso base: array di 1 elemento -> già ordinato //

la ricorsione si ferma return; // chiamo la funzione partition e ottengo l'indice del pivot che memorizzo in k k=partition(a, n); // chiamata ricorsiva: ordino il sottoarray di elementi inferiori al pivot (a sx) - i primi k elementi a partire dal primo a[0] quick_sort(a, k); // chiamata ricorsiva: ordino il sottoarray di elementi superiori/uguali al pivot (a dx) - i successivi n-k-1 elementi a partire dal k+1esimo quick_sort(a+k+1, n-k-1); // per ciascuna chiamata ricorsiva (ovvero ciascun sottoarray finchè n>=2) ripeto il partizionamento // e trovo il nuovo indice del nuovo pivot che separa elementi inferiori e superiori/uguali

for (cont=0; cont<n; cont++)

{

printf("%d ", a[cont]);

}

printf("\n\n");

}

vet[0]=12; vet[1]=1; vet[2]=8; vet[3]=17; vet[4]=25; vet[5]=3; vet[6]=44; vet[7]=12; vet[8]=9; vet[9]=30;
vet[0]=12;
vet[1]=1;
vet[2]=8;
vet[3]=17;
vet[4]=25;
vet[5]=3;
vet[6]=44;
vet[7]=12;
vet[8]=9;
vet[9]=30;
printf(" array originario : ");
for (cont=0; cont<ARRAY_MAX; cont++)
{
printf("%d ", vet[cont]);

int main()

{

/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */ int cont; TInfo vet[ARRAY_MAX];

}

printf("\n\n array ordinato con QUICK SORT : \n\n");

quick_sort(vet, ARRAY_MAX);

printf("\n\n");

}

#include <stdbool.h> #include <stdio.h>

#define ARRAY_MAX (10)

typedef int TInfo; /* definizione tipo elemento array di interi */

bool less(TInfo a, TInfo b)

{

return a < b;

}

/* ritorna true se a precede (è più piccolo di) b */

/* Fonde due array ordinati in un nuovo * array che conserva l'ordinamento. */

void merge(TInfo a1[], int n1, TInfo a2[], int n2, TInfo dest[])

{

int pos1=0, pos2=0, k=0; // pos1 è l'indice del primo elemento inutilizzato del segmento a1[] / pos2 del secondo // k è l'indice dell'array temporaneo dest[]

while (pos1<n1 && pos2<n2) // il primo while viene eseguito finchè in entrambi i segmenti ci sono elementi da utilizzare

{

// il minor elemento tra il primo inutilizzato di a2[] ed il primo inutilizzato di a1[] viene copiato nell'array dest // poi incremento k e pos1 o pos2 (a seconda di quale elemento ho utilizzato) e proseguo if (less(a2[pos2], a1[pos1])) dest[k++] = a2[pos2++];

else

dest[k++] = a1[pos1++];

}

while (pos1<n1) elementi di a1[] inutilizzati dest[k++] = a1[pos1++]; ordine in dest[])

// il secondo ciclo while si esegue se restano

// (essendo gli elementi già ordinati li copio nello stesso

while (pos2<n2)

// il terzo ciclo while si esegue se restano elementi

di a2[] inutilizzati dest[k++] = a2[pos2++]; // (analogamente li copio nello stesso ordine in dest[])
di
a2[] inutilizzati
dest[k++] = a2[pos2++];
// (analogamente li copio nello stesso ordine in dest[])
}
/*
Ordinamento con l'algoritmo Merge Sort
* Nota:
*
temp e' un array di appoggio delle stesse
*
dimensioni di a
*/
void merge_sort(TInfo a[], int n, TInfo temp[])
{
int i, m=n/2;
if (n<2)
// CASO BASE: se il numero di elementi è 1 il vettore è già ordinato (la
ricorsività non è infinita - si interrompe quando ottengo il caso base)
{
//printf("\n trovato caso base: elemento %d\n", a[0]);
return ;
}
// altrimenti
// DIVIDE: divido array in 2 parti: la prima di m=n/2 elementi (da a
[0] ad a[m-1]); la seconda di n-m elementi (da a[m] ad a[n])
// IMPERA: sono in grado di ordinare i due segmenti di array
applicando ricorsivamente l'algoritmo merge_sort stesso
// la prima chiamata ricorsiva di merge_sort lavora per ordinare la

prima parte di array

// la seconda chiamata ricorsiva lavora con la seconda parte di array // COMBINA: chiamiamo la funzione merge per fondere i due segmenti ordinati in un nuovo array - che viene restituito // NB: si passa ogni volta l'array di appoggio temp che comunque al termine di ogni esecuzione non mantiene informazioni conservate § merge_sort(a, m, temp);

merge_sort(a+m, n-m, temp); // a+m corrisponde all'indirizzo dell'elemento a[m] primo elemento della seconda parte (l'array viene passato per riferimento)

merge(a, m, a+m, n-m, temp);

for(i=0; i<n; i++)

{

a[i]=temp[i]; // § proprio perchè temp[] non conserva i dati, ripasso gli elementi ordinati all'area di memoria iniziale a[] printf("%d ", a[i]);

}

printf("\n\n");

}

int main()

{

/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */ int cont; TInfo tempvet[ARRAY_MAX]; TInfo vet[ARRAY_MAX];

vet[0]=12;

vet[1]=1;

vet[2]=8;

vet[3]=17;

vet[4]=25;

vet[5]=3;

vet[6]=44;

vet[7]=12;

vet[8]=9;

vet[9]=30;

printf(" array originario : ");

for (cont=0; cont<ARRAY_MAX; cont++)

{

printf("%d ", vet[cont]);

}

printf("\n\n array ordinato con MERGE SORT : \n\n");

merge_sort(vet, ARRAY_MAX, tempvet);

printf("\n\n");

}

#include <stdbool.h> #include <stdio.h> #define ARRAY_MAX 10 #define NOT_FOUND (-1) bool equal( int a,
#include <stdbool.h>
#include <stdio.h>
#define ARRAY_MAX 10
#define NOT_FOUND (-1)
bool equal( int a, int b)
{
return a == b;
}
{
int i=0;
while (i<ARRAY_MAX && !equal(a[i], x))
i++;
if (i<ARRAY_MAX)
{
}
else
{
}
}
int main()
{
vet[0]=12;
vet[1]=1;
vet[2]=8;
vet[3]=17;
vet[4]=25;
vet[5]=3;
vet[6]=44;
vet[7]=16;
vet[8]=9;
vet[9]=30;
linear_search(vet, 44);
}

/* a e b sono equivalenti */

/* Ricerca lineare: Restituisce e stampa l'indice di un elemento del vettore a[] che sia equal a x, o restituisce un valore negativo se l'elemento non viene trovato */ int linear_search( int a[], int x)

printf("il numero %d e' nell'array alla posizione %d\n", x, i+1); return i;

printf("il numero %d non è presente nell'array\n", x); return NOT_FOUND;

/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */ int vet[ARRAY_MAX];

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

#define MAXT (25) #define NOT_FOUND (-1)

/* definizione tipo TInfo per rappresentare persone e numeri telefonici

* (la relazione di ordine si assume crescente di cognome e a parità di nome)

* elemento strutturato -> collezione di campi */ typedef struct

{

char * cognome; char * nome; char * telefono;

} TInfo;

/* * Utilizzo la funzione strcmp (string compare) che restituisce :

*

*

*

*

*

*/ bool equal( char * cog, char * nom, char * b0, char * b1)

{

- un valore negativo se il primo elemento di comparazione è più piccolo == viene prima

- zero se sono identici return strcmp(nom, b1)==0 && strcmp(cog, b0)==0; int conf_cognomi; else /*
- zero se sono identici
return strcmp(nom, b1)==0 &&
strcmp(cog, b0)==0;
int conf_cognomi;
else
/* conf_cognomi > 0 */
return false;

- un valore positivo se il primo elemento è più grande == viene dopo

/* a e b sono equivalenti */

}

bool less( char * cog, char * nom, char * b0, char * b1)

{

/* a precede b */

conf_cognomi=strcmp(cog, b0); /* confronta stringhe */ if (conf_cognomi<0) return true; else if (conf_cognomi==0) return strcmp(nom, b1)<0;

}

/* Ricerca dicotomica.

*

Restituisce l'indice di un elemento di a che sia equal a x,

*

o un valore negativo se l'elemento non viene trovato.

*

PRE: l'array struct a e' ordinato per cognome - nome rispetto alla relazione less

*/

int binary_search(TInfo a[MAXT], char * x0, char * x1)

{

int first=0; int last=MAXT-1; int chosen=(first+last)/2;

printf("stai cercando %s %s \n\n", x0, x1);

while (first <= last)

{

printf("--- first %d --- chosen %d --- last %d", first, chosen, last); getchar(); if (equal(a[chosen].cognome, a[chosen].nome, x0, x1))

{

printf("%s %s (%d) --- EQUAL --- %s %s (11)", a[chosen].cognome, a

[chosen].nome, chosen, x0, x1);

getchar(); printf("il numero di %s %s e' : %s\n\n", x0, x1, a[chosen].telefono); return chosen;

}

else if (less(a[chosen].cognome, a[chosen].nome, x0, x1))

{

printf("%s %s (%d) --- LESS --- %s %s (11)", a[chosen].cognome, a

[chosen].nome, chosen, x0, x1);

else

}

{

getchar();

first=chosen+1;

printf("%s %s (%d) --- GREATER --- %s %s (11)", a[chosen].cognome, a

[chosen].nome, chosen, x0, x1);

getchar();

last=chosen-1;

}

chosen=(first+last)/2;

}

printf("il numero di %s %s non e' in elenco\n\n", x0, x1); return NOT_FOUND;

}

int main( int argc, char * argv[])

{

/* definizione vettore struct e suo riempimento con sequenza ordinata di dati */

TInfo elenco[MAXT];

elenco[0].cognome="andreani";

elenco[0].nome="andrea";

elenco[0].telefono="07111111"; elenco[1].cognome="barbareschi"; elenco[1].nome="barbara";
elenco[0].telefono="07111111";
elenco[1].cognome="barbareschi";
elenco[1].nome="barbara";
elenco[1].telefono="07122222";
elenco[2].telefono="carletti";
elenco[2].cognome="carlo";
elenco[2].telefono="07133333";
elenco[3].cognome="danielini";
elenco[3].nome="daniele";
elenco[3].telefono="07144444";
elenco[4].cognome="eletti";
elenco[4].nome="elena";
elenco[4].telefono="07155555";
elenco[5].cognome="fabi";
elenco[5].nome="fabio";
elenco[5].telefono="07166666";
elenco[6].cognome="fiori";
elenco[6].nome="fiorello";
elenco[6].telefono="07177777";
elenco[7].cognome="gennaretti";
elenco[7].nome="gennaro";

elenco[7].telefono="07188888";

elenco[8].cognome="ilari";

elenco[8].nome="ilario";

elenco[8].telefono="07199999";

elenco[9].cognome="loreto";

elenco[9].nome="lorella";

elenco[9].telefono="07112345";

elenco[10].cognome="lucidi";

elenco[10].nome="lucio";

elenco[10].telefono="07123456";

elenco[11].cognome="manuli";

elenco[11].nome="manuela";

elenco[11].telefono="07134567";

elenco[12].cognome="nadini";

elenco[12].nome="nadia";

elenco[12].telefono="07145678";

elenco[13].cognome="nucci";

elenco[13].nome="nuccio";

elenco[13].telefono="07156789";

elenco[14].cognome="osvaldi";

elenco[14].nome="osvaldo";

elenco[14].telefono="07167890";

elenco[15].cognome="poli";

elenco[15].nome="paola";

elenco[15].telefono="07178901";

elenco[16].cognome="polli";

elenco[16].nome="patrizio";

elenco[16].telefono="07189012";

elenco[17].cognome="ranieri";

elenco[17].nome="raniero";

elenco[17].telefono="07190123";

elenco[18].cognome="rodolfini";

elenco[18].nome="rodolfo";

elenco[18].telefono="07122555";

elenco[19].cognome="silvi";

elenco[19].nome="silvia";

elenco[19].telefono="07111333";

elenco[20].cognome="tinelli";

elenco[20].nome="tino";

elenco[20].telefono="07133444";

elenco[21].cognome="ughi";

elenco[21].nome="ugo";

elenco[21].telefono="07155777";

elenco[22].cognome="valori";

elenco[22].nome="valeria";

elenco[22].telefono="07188999";

elenco[23].cognome="zanetti";

elenco[23].nome="zeno";

elenco[23].telefono="07177666";

elenco[24].cognome="zori";

elenco[24].nome="zorro";

elenco[24].telefono="07144111";

}

// E' IL 20^ RECORD con indice 19 //"silvi", "silvia" // PROVARE CON UN NOME
// E' IL 20^ RECORD con indice 19
//"silvi", "silvia"
// PROVARE CON UN NOME CHE NON ESISTE
//"rossi", "paolo"
return 0;

binary_search(elenco, "manuli", "manuela"); // E' IL 12^ RECORD con indice 11 //"manuli", "manuela"