1 / 33

Hashing

Hashing. argomenti. Hashing Tabelle hash Funzioni hash e metodi per generarle Inserimento e risoluzione delle collisioni Eliminazione Funzioni hash per file Hashing estendibile Hashing lineare. Richiamo sul concetto di dizionario. Insieme di coppie del tipo <elemento, chiave>

santa
Télécharger la présentation

Hashing

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation 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

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

  4. Tabelle hash • Adatte per realizzare dizionari • Generalizzazione del concetto di array • Importanti nell’accesso a dati su memoria secondaria • 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

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

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

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

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

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

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

  11. Paradosso del compleanno • scelti 23 individui a caso, la probabilità che due di essi abbiano lo stesso compleanno è > ½ (50.7%) • dimostrare! • in termini di hashing, anche ipotizzando di avere le pseudochiavi a distribuzione uniforme, dopo 22 inserimenti in una tabella di 365 celle, ogni ulteriore inserimento avrà probabilità superiore a ½ di generare una collisione Hashing

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

  13. 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 = “pt”  pseudochiave = 112*21+116*20=340 Ascii(‘p’)=112 Ascii(‘t’)=116 Hashing

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

  15. Divisione • h(k)=k mod |T| - Bassa complessità • Attenzione ai fenomeni di agglomerazione • No potenze di 2: se m=2p 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

  16. Ripiegamento • Chiave k suddivisa in parti k1,k2,....,kn • h(k)=f(k1,k2,....,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

  17. Estrazione • 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 • Il numero ottenuto può essere ulteriormente manipolato • L’indirizzo può dipendere da una porzione della chiave Hashing

  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

  19. Concatenazione • h(k1)= h(k4)=0 • h(k5)= h(k7)=h(k2)=4 0 1 2 3 4 k1 k4 k2 k7 k2 k5 • Es.: h(k)=k mod 5 • k1=0, k4=10 • k5=9, k7=14, k2=4 Hashing

  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

  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 può dipendere anche dal numero di tentativi effettuati • Indirizzo=h(k, i) per l’i-esimo tentativo Hashing

  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

  23. 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

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

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

  26. 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 • agglomerazione primaria = due sequenze di scansione che hanno una collisione rimangono collidenti Hashing

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

  28. Scansione quadratica • h(k, i) = (h’(k)+c1i+c2i2) mod |T|, dove h’(k) è una funzione di hashing, c1 e c2 sono costanti • es. indirizzi scanditi: h’(k), h’(k)+1, h’(k)+2,h’(k)+3… • Es.: h(k, i) = h’(k)+i2, h(k, i+1) = h’(k)+(i+1)2, i=1,..., (|T|-1)/2 • Possibilità di agglomerazione secondaria: se h’(k1)= h’(k2)  h’(k1,i)= h’(k2,i) • Descrivere h(k, i) quando h’(k)=k mod |5| Hashing

  29. Hashing doppio • h(k, i) = (h1(k)+ih2(k)) mod |T|, dove h1(k) e h2(k) sono funzioni di hashing • Anche la modalità di scansione dipende dalla chiave • L’hashing doppio riduce i fenomeni di agglomerazione secondaria • esente da quelli di agglomerazione primaria Hashing

  30. Hashing estendibile • E’ usato nella gestione di file, la cui dimensione può variare. • 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

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

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

  33. H. estendibile - Inserimento extHashInsert (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

More Related