argomenti Hashing Funzioni hash per file Tabelle hash Funzioni hash e metodi per generarle Inserimento e risoluzione delle collisioni Eliminazione

Transcript

1 Hashing

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

3 Implementazione di un dizionario Insieme di coppie del tipo <elemento, chiave> Le chiavi appartengono a un insieme totalmente ordinato Operazioni: insert(el, key) delete(key) search(key) Indirizzamento diretto: si associa ad ogni valore della chiave un indice di un array ricerca in tempo O(1) Problemi? Hashing 3

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

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

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

7 asd_library.hash.hashtable public class HashTable implements Dictionary_adt{ public HashTable() { } this(default_table_size); public HashTable(int size) { allocatetable(size); makeempty(); isrehashable = false; } Hashing 7

8 Funzioni hash perfette e collisioni Funzione hash perfetta: k 1!=k 2 h(k 1 )!= h(k 2 ) Richiede T >= K Raramente ragionevole in pratica In generale T < K (spesso T << K ) 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

9 Requisiti di una funzione hash Uniformità semplice: Pr[h(k)=j] ~ 1/ T 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

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

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

12 Esempio: stringhe 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* *2 0 =240 Ascii( p )=112 Ascii( t )=116 Hashing 12

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

14 Divisione h(k)=k mod T - Bassa complessità Attenzione ai fenomeni di agglomerazione 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

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

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

17 HashTable.hash() public static int hash( String key, int tablesize ){ int hashval = 0; for( int i = 0; i < key.length( ); i++ ) hashval = 37 * hashval + key.charat( i ); hashval %= tablesize; if( hashval < 0 ) hashval += tablesize; return hashval; } Hashing 17

18 Risoluzione delle collisioni 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 18

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

20 Concatenazione/2 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 20

21 Indirizzamento aperto Tutti gli elementi sono memorizzati nella tabella Le collisioni vanno risolte all interno della tabella 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 21

22 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 22

23 HashTable.insert() public Object insert(comparable key ){ int collisionnum = 0; int initialpos = hash( key.tostring(),table.length ); int currentpos=initialpos; while((collisionnum<=table.length)&& table[ currentpos ]!= null &&!table[ currentpos ].equals( key ) ){ currentpos = initialpos + k * ++collisionnum; // Compute ith probe currentpos = currentpos % table.length; // Implement the mod } if (collisionnum > table.length){ System.out.println("Insertion impossible: hash table full"); return null; } Hashing 23

24 HashTable.insert() else if (table[ currentpos ].equals( key ) ){ System.out.println("Element "+ key +" is alredy in the hash table."); return key; }else{ table[ currentpos ] = key; ++currentsize; System.out.println("Insertion: ok!"); return key; } } Hashing 24

25 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 25

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

27 HashTable.remove() public Comparable remove(comparable key ){ int collisionnum = 0; int initialpos = hash( key.tostring(),table.length ); int currentpos=initialpos; while(!table[ currentpos ].equals( key )&& (collisionnum<=table.length)){ currentpos = initialpos + k * ++collisionnum; // Compute ith probe currentpos = currentpos % table.length; // Implement the mod } Hashing 27

28 HashTable.remove() if (!table[ currentpos ].equals( key )){ System.out.println("Element "+ key +" isn't in the hash table."); return null; }else{ System.out.println("Element "+ key +" is removed from the hash table."); table[currentpos]=null; return key; } } Hashing 28

29 Scansione 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) Scansione lineare Scansione quadratica Hashing doppio Si differenziano per complessità e comportamento rispetto a fenomeni di agglomerazione Hashing 29

30 Scansione lineare 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 30

31 Agglomerazione primaria h(k, i) = (h (k)+i) mod 101, h (k)=k mod 101 {2, 103, 104, 105,...} Caso estremo, ma il problema Esiste Prob[cella succ. gruppo]= dim(gruppo + 1)/ T Prob[cella isolata]= 1/ T 100 Hashing 31

32 Scansione quadratica 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 32

33 Hashing doppio 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 33

34 Universal Hashing/1 Nel caso peggiore possono essere scelte n chiavi tali che h(k 1 )= h(k 2 )=. h(k n ). In questo caso il tempo di retrieval è O(n) Qualsiasi funzione hashing deterministica puo incontrare questo caso peggiore. Nell Universal Hashing si definisce una famiglia di funzioni hash. Una delle funzioni è selezionata a priori, in modo indipendente dalle chiavi degli elementi. Hashing 34

35 Universal Hashing/2 H e una famiglia di funzioni hash H e universale se per ogni coppia x,y: #h H:h(x)=h(y)= H / T La probabilità di collisione tra due chiavi è simile ad una scelta casuale di h(x): E[ c xy ] = 1/ T Hashing 35

36 Universal Hashing/3 Come costruire una famiglia universale H di funzioni hash? m= T primo x = <x 0, x 1,.., x r > r+1 bytes a = <a 0, a 1,.., a r > r+1 elementi random in {0,,m-1} h a = r! i= 0 a i x i mod m H contiene m r+1 funzioni H = U a h a Hashing 36

37 Universal Hashing/4 Thm:H è una famiglia universale di funzioni hash Fissati <a 1,.., a r > esiste un solo valore a 0 a r! 0 ( x0 " y0) = " a i( xi " yi )(mod m) i= 0 Percio ogni coppia di x e y collide esattamente per un m r valori della sequenza a Poiche vi sono m r+1 valori possibili per la sequenza a, la collisione avviene con probabilita 1/m Hashing 37