Hashing argomenti n Hashing n n n Tabelle

Hashing

argomenti n Hashing n n n Tabelle hash Funzioni hash e metodi per generarle Inserimento e risoluzione delle collisioni Eliminazione Funzioni hash per file n n Hashing estendibile Hashing lineare Hashing 2

Richiamo sul concetto di dizionario n n n Insieme di coppie del tipo <elemento, chiave> Le chiavi appartengono a un insieme totalmente ordinato Operazioni: n n n insert(el, key) delete(key) search(key) Hashing 3

Tabelle hash n n n Adatte per realizzare dizionari Generalizzazione del concetto di array Importanti nell’accesso a dati su memoria secondaria n n Gli accessi avvengono a memoria secondaria Costo degli accessi predominante Indirizzamento diretto: si associa ad ogni valore della chiave un indice di un array – ricerca in tempo O(1) Problemi? Hashing 4

Indirizzamento diretto n n n 0 2 Ogni chiave corrisponde a el. diverso dell’array Può portare a spreco di memoria Es. : 10000 studenti e matr. = No. decimale a 5 cifre No. chiavi N-1 Hashing 5

Obiettivi n n 0 2 N ~ No. Chiavi effettivamente usate Tempo di ricerca O(1) D. : possibile? Nota: No. Chiavi possibili può essere >> N No. chiavi N-1 Hashing 6

Tabella hash Dato l’insieme base di un dizionario: n <T, h> n T è una tabella n h: K {0, . . . , N-1} n n K insieme delle possibili chiavi {0, . . . , N-1} insieme delle posizioni nella tabella Hashing 7

Funzioni hash perfette e collisioni n Funzione hash perfetta: n n In generale N < |K| (spesso N << |K|) n n k 1!=k 2 h(k 1) != h(k 2) Richiede N >= |K| Raramente ragionevole in pratica Conseguenza: k 1!=k 2 ma h(k 1) == h(k 2) è possibile Collisione Es. : proporre una funzione hash perfetta nel caso in cui le chiavi siano stringhe di lunghezza 3 sull’alfabeto {a, b, c} Hashing 8

Requisiti di una funzione hash n Uniformità semplice: Pr[h(k)=j] ~ 1/|K| n n La probabilità è calcolata rispetto alla distribuzione delle chiavi Intuitivamente, si desidera che gli elementi si distribuiscano nell’array in modo uniforme Difficile costruire funzioni che soddisfino la proprietà D. : perché? Hashing 9

Requisiti di una funzione hash/2 n Esempio: sia |T|=5 e h(k)=k mod 5 {1, 7, 10, 14} • Non è nota la distribuzione delle chiavi • Può aversi agglomerazione degli elementi {1, 6, 11, 16} 0 1 2 3 4 In pratica: si cerca di avere indipendenza dai dati Hashing 10

Interpretazione delle chiavi n n Tra gli elementi di K è definito un ordinamento totale ma: Le chiavi non sono necessariamente numeri naturali (o persino numeri) n n n Es. : stringhe Soluzione: associare a ciascuna chiave un intero Modalità dipendono da insieme delle chiavi e applicazione Hashing 11

Esempio: stringhe n n Possibile metodo: associare a ciascun carattere il valore ASCII e alla stringa il numero intero ottenuto in una base scelta Esempio: base 2, posizioni meno significative a destra Stringa = “p t” chiave = 112*21+116*20=240 Ascii(‘p’)=112 Ascii(‘t’)=116 Hashing 12

Derivazione di funzioni hash n Molti metodi n n n n Divisione Ripiegamento Mid-square Estrazione. . . Obiettivo: distribuzione possibilmente uniforme Differenze: n n Complessità Fenomeni di agglomerazione Hashing 13

Divisione n n h(k)=k mod |T| - Bassa complessità Attenzione ai fenomeni di agglomerazione n n No potenze di 2: se m=2 p allora tutte le chiavi con i p bit meno significativi uguali collidono No potenze di 10 se le chiavi sono numeri decimali (motivo simile) In generale, la funzione dovrebbe dipendere da tutte le cifre della chiave (comunque rappresentata) Scelta buona in pratica: numero primo non troppo vicino a una potenza di 2 (esempio: h(k)=k mod 701 per |K|=2048 valori possibili) Hashing 14

Ripiegamento n n n Chiave k suddivisa in parti k 1, k 2, . . , kn h(k)=f(k 1, k 2, . . , kn) Esempio: la chiave è un No. di carta di credito. Possibile funzione hash: 1. 4772 6453 7348 {477, 264, 537, 348} 2. f(477, 264, 537, 348) = (477+264+537+348)mod 701 = 224 Hashing 15

Estrazione n n Si usa soltanto una parte della chiave per calcolare l’indirizzo Esempio: 6 cifre centrali del numero di carta di credito 4772 6453 7348 264537 n n Il numero ottenuto può essere ulteriormente manipolato L’indirizzo può dipendere da una porzione della chiave Hashing 16

Risoluzione delle collisioni n n n I metodi si distinguono per la collocazione degli elementi che danno luogo alla collisione Concatenazione: alla i-esima posizione della tabella è associata la lista degli elementi tali che h(k)=i Indirizzamento aperto: tutti gli elementi sono contenuti nella tabella Hashing 17

Concatenazione h(k 1)= h(k 4)=0 h(k 5)= h(k 7)=h(k 2)=4 n n 0 1 2 3 4 n n n k 1 k 4 k 7 k 5 Es. : h(k)=k mod 5 k 1=0, k 4=10 k 5=9, k 7=14, k 2=4 Hashing k 2 18

Concatenazione/2 n n n insert(el, k): inserimento in testa alla lista associata alla posizione h(k) – costo O(1) search(k): ricerca lineare nella lista associata alla posizione h(k) – costo O(lungh. lista associata a h(k)) delete(k): ricerca nella lista associata a h(k), quindi cancellazione – costo O(lungh. lista associata a h(k)) Hashing 19

Indirizzamento aperto n n Tutti gli elementi sono memorizzati nella tabella Le collisioni vanno risolte all’interno della tabella n n Se la posizione calcolata è già occupata occorre cercarne una libera I diversi metodi ad indirizzamento diretto si distinguono per il metodo di scansione adottato La funzione hash dipende anche dal numero di tentativi effettuati Indirizzo=h(k, i) per l’i-esimo tentativo Hashing 20

Inserimento insert (el, k) { /* T denota la tabella */ i=0; while (h(k, i) <occupata> && (i<|T|)) i++; if (i < |T|) <inserisci el in pos. i> else <overflow> } Hashing 21

Ricerca search (k) { /* T denota la tabella */ i=0; while ((k!=key(T[h(k, i)])) && (i<|T|)) i++; if (i < |T|) <restituisci T[h(k, i)]> else <elemento assente> } Hashing 22

Cancellazione delete (k) { /* T denota la tabella */ search(k); if (<trovato>) <elimina elemento con chiave k> } Hashing 23

Scansione n n La funzione h(k, i) deve essere tale che tutte le posizioni della tabella siano esaminate Sono possibili diverse forme per la funzione h(k, i) n n Scansione lineare Scansione quadratica Hashing doppio Si differenziano per complessità e comportamento rispetto a fenomeni di agglomerazione Hashing 24

Scansione lineare n n n h(k, i) = (h’(k)+i) mod |T|, dove h’(k) è una funzione di hashing Si scandiscono tutte le posizioni nella sequenza T[h’(k)], T[h’(k)]+1, . . T[|T|], 0, 1, . . , T[h’(k)]-1 Possibilità di agglomerazione primaria: gli elementi si agglomerano per lunghi tratti Hashing 25

Agglomerazione primaria n h(k, i) = (h’(k)+i) mod 101, h’(k)=k mod 101 {2, 103, 104, 105, . . } Caso estremo, ma il problema esiste 0 1 2 100 Hashing 26

Scansione quadratica n n h(k, i) = (h’(k)+c 1 i+c 2 i 2) mod |T|, dove h’(k) è una funzione di hashing, c 1 e c 2 sono costanti Es. : h(k, i) = h’(k)+i 2, h(k, i+1) = h’(k)-i 2, i=1, . . . , (|T|-1)/2 Possibilità di agglomerazione secondaria: se h’(k 1)= h’(k 2) h’(k 1, i)= h’(k 2, i) Descrivere h(k, i) quando h’(k)=k mod |5| Hashing 27

Hashing doppio n n h(k, i) = (h 1(k)+ih 2(k)) mod |T|, dove h 1(k) e h 2(k) sono funzioni di hashing Es. : h(k, i) = h’(k)+i 2, h(k, i+1) = h’(k)-i 2, i=1, . . . , (|T|-1)/2 Anche la modalità di scansione dipende dalla chiave L’hashing doppio riduce i fenomeni di agglomerazione Hashing 28

Hashing estendibile n E’ usato nella gestione di file, la cui dimensione può variare. n n Es. : file ad accesso diretto Il file è organizzato in bucket, ciascuno dei quali ha una dimensione fissa Gli indirizzi sono associati ai bucket La funzione hash restituisce in questo caso un puntatore al bucket Hashing 29

Hashing estendibile/2 n n h(k) restituisce una stringa binaria b I bit più significativi di b sono usati per determinare l’indirizzo del bucket File Lungh. locale 2 Bucket 00 Lungh. globale h(k)=11001 2 2 Bucket 01 00 01 10 1 11 Bucket 1 Indice Hashing 30

Esempio File 2 1 01100 00001 01100 h(k)=00101 1 Bucket 0 00 1 01100 Bucket 01 10010 Bucket 1 2 10 10010 Bucket 00 2 0 Indice 00001 00101 Bucket 1 11 Indice Dim. Bucket = 4 Hashing 1 31

H. estendibile - Inserimento ext. Hash. Insert (el, k) { /* L=lunghezza globale */ str=h(k); /* LS= lunghezza str */ p=indice[pattern[LS-1. . . LS-L]]; if (<Bucket puntato da p non pieno) <inserisci el> else { <suddividi bucket> /* l=lunghezza locale bucket*/ l++; <inserisci el> } if (l > L) <Raddoppia indice> L++; } Hashing 32