#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 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
variabile di appoggio temp)
*/
void swap(TInfo *a, TInfo *b)
{
TInfo temp=*a;
*a=*b;
*b=temp;
}
/* Ricerca la posizione del minimo in un array.
* PRE: n>0
* 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 (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
}
if (k==n-1 || !modified)
printf("\n\n array ordinato con BUBBLE SORT : ");
else
printf("\n\n array parziale dopo iterazione %d : ", k+1);
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 (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)

{
return a > b;
}

/* ritorna true se a segue ( pi grande di) 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 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>
#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)
{
TInfo temp=*a;
*a=*b;
*b=temp;
}
/* 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;
// la funzione partition restituisce il nuovo indice del pivot
}
/* Ordina un array con il Quick Sort
*/
void quick_sort(TInfo a[], int n)
{
int k, cont;
if (n<2)
// 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");
}
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\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)
di a2[] inutilizzati
dest[k++] = a2[pos2++];
}

// il terzo ciclo while si esegue se restano elementi

// (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, int b) /* a e b sono equivalenti */
{
return a == b;
}
/* 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)
{
int i=0;
while (i<ARRAY_MAX && !equal(a[i], x))
i++;
if (i<ARRAY_MAX)
{
printf("il numero %d e' nell'array alla posizione %d\n", x, i+1);
return i;
}
else
{
printf("il numero %d non presente nell'array\n", x);
return NOT_FOUND;
}
}
int main()
{
/* definizione vettore monodimensionale e suo riempimento con sequenza di numeri interi */
int 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]=16;
vet[8]=9;
vet[9]=30;
linear_search(vet, 44);
}

#include
#include
#include
#include

<stdbool.h>
<stdio.h>
<string.h>
<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 :
*
- un valore negativo se il primo elemento di comparazione pi piccolo == viene prima
*
- zero se sono identici
*
- un valore positivo se il primo elemento pi grande == viene dopo
*
*
*/
bool equal(char* cog, char* nom, char* b0, char* b1) /* a e b sono equivalenti */
{
return strcmp(nom, b1)==0 &&
strcmp(cog, b0)==0;
}
bool less(char* cog, char* nom, char* b0, char* b1) /* a precede b */
{
int conf_cognomi;
conf_cognomi=strcmp(cog, b0); /* confronta stringhe */
if (conf_cognomi<0)
return true;
else if (conf_cognomi==0)
return strcmp(nom, b1)<0;
else /* conf_cognomi > 0 */
return false;
}
/* 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);
getchar();
first=chosen+1;
}
else
{
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[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";
binary_search(elenco, "manuli", "manuela");
// E' IL 12^ RECORD con indice 11
//"manuli", "manuela"
// E' IL 20^ RECORD con indice 19
//"silvi", "silvia"
// PROVARE CON UN NOME CHE NON ESISTE
//"rossi", "paolo"
return 0;
}