29 november 2012 Hashing. Een tijd-ruimte afweging Hashfuncties

Transcriptie

1 Hashing Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering 29 november 2012 ODE/FHTBM Hashing 29 november /30 Hashing Een typisch gebruik van de implementatie van hashing zijn dictionairs. Elke dictionair bestaat uit een lijst van sleutel die aan een of meerdere (!) objecten gerelateerd zijn. Hashing is een uitbreiding van zoeken op index-sleutel en gaat verder dan de standaard zoektoepassingen. Het resultaat is wezenlijk verschillend voor de manier waarop gezocht wordt [en kan daarom onafhankelijk daarvan bekeken worden]. ODE/FHTBM Hashing 29 november /30 Hashing 2 Hashing is: direct naar elementen verwijzen via rekenkundige operaties. Se zullen diverse technieken beschouwen: Separate Chaining Double Hashing Deze rekenkundige bewerkingen worden door zogenaamde hashfuncties geïmplementeerd. ODE/FHTBM Hashing 29 november /30 1

2 Basis idee Zoekalgoritmen, die hashing gebruiken bestaan uit twee gescheiden delen. 1 Berekenen van een hashfunctie die de zoeksleutel omzet in een tabeladres, en een 2 Methode om botsingen te verwerken voor deze sleutel. De hashfunctie beeldt de sleutel af op een positie in een hashtabel. In het ideale geval: a Direct Access Table: (An array!?) 1 Als item i een sleutel k heeft en h(x) een hashfunctie is, wordt i op positie h(k) van de tabel afgebeeld. 2 Hier geen collisions. 3 Om te zoeken naar i berekenen we h(k) waarmee de positie gevonden kan worden. Als er geen element bestaat, zit die ook niet in de dictionary. ODE/FHTBM Hashing 29 november /30 Voorbeeld: dictionair met studentgegevens De sleutels zijn de studentnummers (ID s) ( ) niet meer dan 1001 studenten Hashfunctie: h(k) = k beeldt de ID s van de studenten af op een bepaalde tabelpositie in het bereik array table[1000] [0] [1] [2] [3] [1000] buckets ODE/FHTBM Hashing 29 november /30 Voorbeeld: Dictionair met studentgegevens (2) In het gegeven voorbeeld zien we dat we O(N) tijd nodig hebben om de hashtabel te initialiseren (N is het aantal posities of buckets in de hashtabel) en O(1) tijd om toevoegen en zoeken uit te voeren. Het ideale geval is onrealistisch. Voor de implementering van een dictionair werkt het, maar een sleutelbereik kan te groot zijn voor een 1-1 afbeelding op de buckets! Voorbeeld: neem aan dat een sleutel een waarde kan hebben in (2-byte unsigned integer) Accepteer ongeveer 1000 records op een willekeurig moment. Een hashtabel met (>> 1000) posities is erg onhandig. ODE/FHTBM Hashing 29 november /30 2

3 Een tijd-ruimte(opslag) afweging Hashing is een goed voorbeeld van een afweging tussen looptijd en opslagruimte. Bekijken we eens de volgende extrema aan: 1 Als er onbeperkt geheugencapaciteit was, konden we elke willekeurige zoekopdracht met een enkele geheugenbewerking doen. De benodigde hoeveelheid geheugen kan ontoereikend zijn als de sleutels te lang zijn. 2 Als er geen tijdslimiet was, konden we met een minimum aan geheugenruimte werken, door een sequentiële zoekmethode te gebruiken. ODE/FHTBM Hashing 29 november /30 Een tijd-ruimte(opslag) afweging (2) Hashing maakt een balancering tussen geheugen en tijd mogelijk doordat van beide een bepaalde hoeveelheid nodig is. We kunnen een evenwicht bereiken doordat we de tabelgrootte aanpassen zonder de code te herschrijven of andere algoritmne toe te passen. We ondersteunen de belangrijke operaties search en insert. Gemiddeld verbruiken beide operaties search en insert constante tijd. In worst case is de tijd evenredig aan de verzameling operaties, die door de datastructuur (bijv. arrays) wordt vastgelegd. Hashing biedt geen efficiente implementaties voor andere symbooltabel-operaties zoals select of sort ODE/FHTBM Hashing 29 november /30 Keren we naar ons voorbeeld terug. Als het sleutelbereik te groot is, moeten we een hashtabel nemen met minder posities (buckets) en een hashfunctie die meerdere sleutels op dezelfde positie afbeeldt. h(k 1 ) = β = h(k 2 ) : voor k 1 en k 2 is er een collision bij positie β. Populaire hash-functies gebruiken: hashing by division (hashing door deling) h(k) = k%m; waarin M het aantal posities in de Hash-Tabelle is. ODE/FHTBM Hashing 29 november /30 3

4 Voorbeeld Voorbeeld: hashtabel met 11 posities h(k) = k% (80% 11 = 3) collision! ODE/FHTBM Hashing 29 november /30 String sleutels Tot nu toe hebben we met numerieke sleutels gewerkt. Java implementaties worden gerealiseerd via hashfuncties voor string sleutels. De sleutel wordt berekend via vermenigvuldigingen en optellingen per karakter in de sleutel. Methode von Horner mit umgesetzt in Array-Index: int hash ( String s, int M) { int h = 0, R = 127; for ( int i = 0; i < s. length (); i ++) h = (R*h + s. charat (i)) % M; return h; ODE/FHTBM Hashing 29 november /30 Voorbeeld We kunnen de hashfunctie berekenen voor: averylongkey Een 7-bit ASCII-code levert voor deze tekst: Een 84-bit getal! Het programma gebruikt 127 inplaats van 128 voor betere randomverdeelde sleutelwaarden. Als bijvoorbeeld M = 64, zou meermaals 128 erbij optellen leiden tot veel identieke sleutelwaarden. Als men pseudo-random coëfficiënten gebruikt heet de methode Universal Hashing. Zie hashu methode on next slide. ODE/FHTBM Hashing 29 november /30 4

5 Universal hash function (for string keys) static int hashu ( String s, int M) { int h = 0, r1 = 31415, r2 = 27183; for ( int i =0; i < s. length (); i ++) { h = (r1*h + s. charat (i)) % M; r1 = r1*r2 % (M -1); return h; Deze aanpak zorget er voor dat de kans op een collison tussen twee identieke sleutels gelijk aan 1 M is. ODE/FHTBM Hashing 29 november /30 Universal hash function (for string keys) (2) In de hashu methode is een effectievere benadering geimplementeerd, gebruik (pseudo) random waarden voor de coefficienten in de berekening, en een andere random waarde voor elke positie in de sleutel. Deze procedure geeft een random-algoritme dat universal hashing wordt genoemd. ODE/FHTBM Hashing 29 november /30 Implementatie voor zelfgedifieerd type public class Transaction { private final String who ; private final Date when ; private final double amount ; public int hashcode () { int hash = 17; hash = 31+ hash + who. hashcode (); hash = 31* hash + when. hashcode (); hash = 31* hash + (( Double ) amount ). hashcode (); return hash ; ODE/FHTBM Hashing 29 november /30 5

6 Drie primaire voorwaarden voor een goede hash Ze moet consistent zijn: gelijke sluetels moeten dezelfde hashwaarde krijgen. Het moet efficient te berekenen zijn. De sleutels moeten uniform verdeeld zijn. Een slechte hash-functie is een klassiek voorbeeld van een performance bug. ODE/FHTBM Hashing 29 november /30 De collison-afhandeling beinvloedt de keuze voor de hashfunctie. We onderscheiden twee verschillende hashing-typen 1 Open hashing, (separate chaining) 2 Gesloten hashing (closed hashing) De verschillen zijn collisions opgeslagen worden buiten de tabel (open hashing) of dat collisions ervoor zorgen dat een deel van de data op een andere positie in de tabel opgeslagen wordt (gesloten hashing). ODE/FHTBM Hashing 29 november /30 Rehash-strategie: Linear-probing Finde ein leeres bucket Aanname J: De hashfuncties die we gebruiken verdelen de sleutels uniform en onafhankelijk. Bij closed-hashing hoort een rehash-strategie: als we proberen x in positie h(x) onder te brengen die reeds bezet is, zoeken we alternatieve plaatsen h1(x), h2(x), enz. Als er geen lege plaats gevonden wordt is de tabel vol. h(x) heet home bucket. De eenvoudigste Rehash-strategie heet Linear Hashing of (lineair proberen) h i (x) = (h(x) + i)%m Onze collison oplossings-strategie is zodanig dat we een reeks van posities (probe sequence) in de hashtabel genereren die de data kan opnemen. Dan testen we elke bucket totdat we een lege vinden (probing). ODE/FHTBM Hashing 29 november /30 6

7 Voorbeeld: M = 8, de sleutels a, b, c, d hebben de hashwaarden: h(a) = 3, h(b) = 0, h(c) = 4 en werden al toegevoegd. Waar voegen we d met h(d) = 3 in? Bucket 3 is al gevuld. Die Probeer-reeks bij lineair hashing is h 1 (d) = (h(d) + 1)%8 = 4%8 = 4 h 2 (d) = (h(d) + 2)%8 = 5%8 = 5 h 3 (d) = (h(d) + 3)%8 = 6%8 = 6 etc. 7, 0, 1, 2 Loopt over naar begin van de tabel! ODE/FHTBM Hashing 29 november /30 Resultaat van linair probing in voorbeeld lineair hashing [0] [1] [2] [3] [4] [5] [6] [7] b a c d ODE/FHTBM Hashing 29 november /30 Nog een voorbeeld: Linear probing Wat gebeurt als het volgende item home-bucket 0 heeft? Er zijn enkele elementen met home-bucket 1 of 2. Het record komt op positie 3. Netzo worden records op 7 of 8 of 9 hashen uiteindelijk in 10 terecht komen. Records met hashing op 4 worden in 4 geplaatst; datzelfde geldt voor 5 en bij home-bucket 7 invoegen (1052%11 = 7) Het volgende element wordt op positie 3 geplaatst. ODE/FHTBM Hashing 29 november /30 7

8 Nog een voorbeeld: Linear probing (2) [0] [0] [1] 9537 [1] [2] 3016 [2] [3] [3] [4] [4] [5] [5] [6] [6] [7] 9874 [7] [8] 2009 [8] [9] 9875 [9] [10] [10] ODE/FHTBM Hashing 29 november /30 Voorbeeld items : A S E R C H I N G X M P hashcode : A S A S A E S A E R S A C E R S H A C E R S H A C E R I S H A C E R I N G S H A C E R I N G X S H A C E R I N G X M S H A C E R I N G X M S H P A C E R I N ODE/FHTBM Hashing 29 november /30 Implementatie voor Lineair Probing Algorithm 3.6 public class LinearProbingHashST <Key, Value > { private int N; // number of key - value pairs in the symbol table private int M = 16; // size of linear probing table private Key [] keys ; // the keys private Value [] vals ; // the values public LinearProbingHashST () { keys = ( Key []) new Object [M]; vals = ( Value []) new Object [M]; private int hash ( Key key ) { return ( key. hashcode () & 0 x7fffffff ) % M; public void put ( Key key, Value val ) { if ( val == null ) delete ( key ); if (N >= M /2) resize (2* M); int i; for (i = hash ( key ); keys [i]!= null ; i = (i + 1) % M) { if ( keys [i]. equals ( key )) { vals [i] = val ; return ; keys [i] = key ; vals [i] = val ; N ++; public Value get ( Key key ) { for ( int i = hash ( key ); keys [i]!= null ; i = (i + 1) % M) if ( keys [i]. equals ( key )) return vals [i]; return null ; ODE/FHTBM Hashing 29 november /30 8

9 Operaties en lineaire probing: verwijderen Bekijk zoeken van een item: test h(k), h 1 (k), h 2 (k),..., totdat k of een lege positie of een home bucket vinden Als niets kan worden verwijderd functioneert de strategie! Wat gebeurt er als er moet worden verwijderd? Als we een lege bucket bereiken, kunnen we er niet zeker van zijn dat k niet ergens anders is en de lege bucket bezet was toen k ingevoegd werd. We hebben een speciale plaatshouder gewist nodig, om een bucket dat nooit werd gebruikt te kunnen onderscheiden van een die ooit een waarde bevatte. We moeten de hashtabel waarschijnlijk reorganiseren nadat er veel verwijderingen hebben plaatsgevonden. ODE/FHTBM Hashing 29 november /30 Verwijderen bij linear probing (LinearProbingHashST.java) public void delete ( Key key ) { if (! contains (key )) return ; int i = hash ( key ); while (! key. equals ( keys [i ])) { i = (i + 1) % M; keys [i] = null ; vals [i] = null ; i = (i + 1) % M; while ( keys [i]!= null ) { Key keytorehash = keys [i]; Value valtorehash = vals [i]; keys [i] = null ; vals [i] = null ; N - -; put ( keytorehash, valtorehash ); i = (i + 1) % M; N - -; if (N > 0 && N <= M /8) resize (M /2); ODE/FHTBM Hashing 29 november /30 Analyse voor linear probing Inititalisatie: O(M), waar M het aantal buckets is Invoegen en zoeken: O(N), waarbij N het aantal elementen (of items) in de tabel is; alle N sleutelwaarden hebben dezelfde home bucket Voor het onderhoud van een woordenboek is er niets beter dan een lineaire lijst! ODE/FHTBM Hashing 29 november /30 9

10 Prestatieanalyse voor het gemiddelde geval De gemiddelde kosten van linear probing hangt af van de wijze waarop items clusteren in samenhangende groepen van bezette tablecellen bij het invoegen. We verwachten dat de kosten voor hashing een functie is van de mate waarin de tabel gevuld is: DEF: lastfactor α = N/M GHemiddelde kosten met aanname J van linear-probing: Definition (Propostion M.) Aantal probes voor geslaagde zoekactie: 1 2 ( α ) Aantal probes voor gefaalde zoekactie: 1 2 (1 + 1 (1 α) 2 ) Ondezoek de grenswaarden α = 0 en α = 1. ODE/FHTBM Hashing 29 november /30 Meerdere probing benaderingen Lineare Probing h i (x) = (h(x) + i)%m Alle buckets in de tabel zijn kandidaten voor invoegen van een nieuw record voordat de probe sequence naar de home positie terugkeert. Clustering van records leidt tot lange probeerreeksen Lineaire probing met overslaan h i (x) = (h(x) + i c)%m c is een constante ( 1) Records met dezelfde home-bucket volgen niet dezelfde probeerreeks (Pseudo-)random probing h i (x) = (h(x) + r i )%M r i is de i-de waarde in een toevals-permutatie van getallen 1 tot M 1; zie Universal Hashing. Invoegen en zoeken gebruiken dezelfde reeks van random getallen. ODE/FHTBM Hashing 29 november /30 Een ander soort verbetering: double hashing We gebruiken twee hashing-methoden: dubbele hashing (double hashing). Om clustering te vermijden: groepsvorming van gevulde cellen. void insert ( Item x) { Key key = x. getkey (); int i = hash (key, M); int k = hashtwo ( key ); while ( storage [i]!= null ) { i = (i+k) % M; storage [i] = x; N ++; // item stored Item search ( Key key ) { int i = hash (key, M); int k = hashtwo ( key ); while ( storage [i]!= null ) if ( equals (key, storage [i]. getkey ())) { return storage [i]; // item found else { i = (i+k) % M; return null ; ODE/FHTBM Hashing 29 november /30 10