Appunti per il modulo di algoritmi e strutture dati - Sezione di ...

Se gli elementi dell’insieme sono mantenuti ordinati, è possibile una ricerca più efficiente, detta ricerca
binaria o logaritmica, simile a quella utilizzata per l’albero binario di ricerca, che consiste nell’esaminare
l’elemento centrale dell’array e, se questo è diverso dall’elemento da ricercare, andare a cercare nella
prima metà dell’array, mentre, se è maggiore, nella seconda metà. L’algoritmo può essere definito nel
modo seguente:
int binSearch ( InfoType *A , InfoType x, int i=0 , int j=n -1) {
if (i > j) return 0;
int k=(i+j )/2;
if (x == A[k]) return 1;
if (x < A[k]) return binSearch (A, x, i, k -1);
else return binSearch (A, x, k+1 , j)
}
È facile dimostrare per induzione la correttezza del programma. La relativa relazione di ricorrenza è :
T (0) = a
T (n) = T ( n
2 ) + b n > 0
e quindi T (n) è O(log n). Per quanto visto nel capitolo sui limiti inferiori, abbiamo che il problema
della ricerca con algoritmi basati su confronti è Ω(log n). Quindi la ricerca binaria raggiunge tale limite
inferiore. Naturalmente può non essere conveniente per implementare un insieme se ci sono frequenti
inserzioni e cancellazioni, poiché l’array deve rimanere ordinato.
11.2 Metodo hash
Un metodo di ricerca in un insieme, non completamente basato su confronti, è il metodo detto hash
(to hash = rimescolare). Questo metodo consiste nel definire una funzione hash h che associa ad ogni
elemento dell’insieme una posizione nell’array (indirizzo hash), cioè h: InfoType → indici. Questo vuol
dire che, se l’elemento x è presente nell’insieme, esso deve trovarsi nella posizione corrispondente all’indice
h(x). Una funzione hash genera tutti e soli gli indici dell’array, quindi h deve essere surgettiva. Quando h
è anche iniettiva, la posizione degli elementi è essere sempre diversa per elementi diversi. Se h è iniettiva,
abbiamo il cosiddetto accesso diretto:
bool hashSearch ( InfoType *A , int n, InfoType x) {
int i=h(x); if (A[i ]== x) return true ;
else return false ;
}
La complessità della ricerca è ovviamente O(1), se il tempo per il calcolo della funzione hash è costante.
Naturalmente l’inserimento di un elemento x deve essere effettuato in posizione h(x) e la cancellazione di
un elemento x inserirà un particolare valore in h(x), che indica che l’array non contiene elementi in quella
posizione. Un esempio di funzione hash iniettiva, se gli elementi sono interi, è h(x) = x. Se non abbiamo
alcuna informazione sulla struttura degli elementi dell’insieme, per progettare un accesso diretto bisogna
prevedere tutte i possibili elementi e questo, in generale, porta ad una dimensione dell’array che è di
molto superiore al numero massimo n di elementi dell’insieme. Per esempio, se volessimo utilizzare una
ricerca ad accesso diretto per un insieme di parole italiane di lunghezza inferiore o uguale a 10, dovremmo
associare ad ognuna delle possibili sequenze di caratteri di lunghezza inferiore o uguale a 10 un indice
diverso, e le sequenze di caratteri di lunghezza inferiore o uguale a 10 sono 26 10 + 26 9 + . . . 26, mentre il
numero di parole italiane formate al massimo da 10 caratteri è di molto inferiore.
Se ci sono esigenze di ottimizzazione dell’occupazione di memoria tali da non permettere l’uso di una
funzione hash iniettiva, è necessario rilasciare il vincolo della iniettività. Se la dimensione dell’array è
48