Upload
alexander-van
View
219
Download
0
Tags:
Embed Size (px)
Citation preview
1
Hashtabellen
Datastructuren
2
Dit onderwerp
• Direct-access-tabellen
• Hashtabellen– Oplossen van botsingen met “ketens” (chaining)– Analyse– Oplossen van botsingen door “open addressing”
• HashfunctiesHash: “mix”, “schud” …Hash: “mix”, “schud” …
3
Datastructuren voor Dictionaries
• Operaties op een verzameling:– Zoek (Search)
– VoegToe (Insert)
– LaatWeg (Delete)
• Veel toepassingen
• Andere datastructuur: Zoekbomen– Bieden meer operaties (successor, minimum, etc.)
– Zijn in de praktijk wat langzamer als we alleen zoeken, toevoegen, en weglaten
– Komen later
4
Direct-access tabellen
• Array met positie (slot) voor elke mogelijke key
• Grootte array dus even groot als aantal mogelijke keys
• Nadeel: veel geheugen als er veel verschillende keys zijn
• Soms nuttig: bij weinig keys– Bijv. Key is lengte persoon in
mm (< 3000 verschillende keys)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
3 + extra info
6 + extra info
11 + extra info
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
5
Hash-tabellen
• Als er veel keys zijn
– Is een direct-access-table te groot
– Maar kunnen we iets anders doen: hashtabel
• Neem een functie f, die iedere mogelijke key afbeeldt op een positie in de tabel (hashfunctie)
• Iets doen als er meer keys op dezelfde plek komen
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
3 + extra info
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
40 + extra info
28 + extra info
f(x) = x mod 17
6
Hash-functies
• Stel iedere key komt uit een universum U (eindige of oneindige verzameling)
• We hebben een functie h: U {0, 1, …, m-1} – m is de grootte van
de tabel / het array
• Vaak gebruikte hashfuncties:
• U = N = {0, 1, 2, …}• h(k) = k mod m• Goede waardes voor m:
priemgetallen, niet in de buurt van 2-macht
• Slechte waardes voor m: machten van 2, machten van 10, …
7
Oplossen van botsingen: “ketens”
• Botsingen (collisions): als we twee keys x en y willen hashen met h(x) == h(y)
• Oplossing 1: op elke positie van de hashtabel een pointer naar een gelinkte lijst (chaining)
• Oplossing 2: slim op een andere plek in de tabel zetten (open addressing) komt later
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
3
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
leeg
23 6
28 62
8
Hashing met chaining
• Gelinkte lijst per positie in de tabel• NIL als lijst leeg• Chained-Hash-Insert(T,x)
– Voeg x toe aan kop van de lijst T[h(key(x))]• Chained-Hash-Search(T,x)
– Loop door de lijst T[h(key(x))] totdat je aan het eind van de lijst gekomen bent (false) of je een element met key x tegenkomt (gevonden, lever element op)
• Chained-Hash-Delete(T,x)– Loop door de lijst T[h(key(x))] totdat je aan het eind van de lijst gekomen
bent (false) of je een element met key x tegenkomt en delete dan dat element
• Tijd:– Insert O(1), – Search en Delete O(1+lengte T[h(key(x))])
9
Analyse van zoeken en weglaten
• Tijd is lineair in lengte van de gelinkte lijst van de betreffende key
• Stel tabel heeft m posities• Stel we slaan n elementen op• Slechtste geval: alle elementen hashen naar zelfde positie:
(n) tijd• In het gemiddelde geval gaat het wel vaak goed, als we een
“goede” hashfunctie hebben• “Simple uniform hashing” aanname: elk element heeft
kans 1/m voor elk van de slots, onafhankelijk van de andere elementen– Is in feite een versimpeling van de werkelijkheid, maar helpt wel om
een redelijk inzicht te krijgen
10
Uniforme verdeling
• Kansberekening: uniforme verdeling• Kansexperiment met aantal mogelijke
uitkomsten• Uniforme verdeling: elke uitkomst is even
waarschijnlijk– Eerlijke dobbelsteen: elke uitkomst heeft kans
1/6– Eerlijke munt: kans op kop = kans op munt = ½
11
Verwachtingswaarde
• Stel, we herhalen een experiment k keer. Elk experiment kan “succesvol” of “onsuccesvol” zijn.
• Wat is het verwachtte aantal keren dat we succes hebben?
12
Aanname: onafhankelijkheid
• Twee experimenten zijn onafhankelijk als
– Pr(x and y) = Pr(x) * Pr(y)• Intuïtie: uitkomst voor ene experiment beïnvloedt niet de
uitkomst voor het andere experiment• Als we een experiment herhalen, is de aanname dat de
opeenvolgende experimenten onafhankelijk zijn– In de praktijk een UITERST goede benadering van de
werkelijkheid– Slijtage van dobbelsteen zou dobbelsteenworpen afhankelijk
kunnen maken maar effect is zo klein dat het verwaarloosbaar is
13
Aantal successen bij herhaald experiment
• E(aantal successen bij k keer een experiment met kans 1/q) = k/q
• E(aantal successen bij k keer een experiment met kans p) = kp
• E: verwachtingswaarde
14
Verwachte lengte van lijstje
• Aannames:– Uniforme verdeling over waar elementen in de
hashtabel komen– Onafhankelijkheid
• Als we n elementen in de hashtabel zetten en we hebben m posities in de tabel:– Verwacht n/m elementen voor de lengte van
een element in de tabel
15
Analyse
• Schrijf n(j) is aantal keys op positie j = lengte gelinkte lijst T(j)
• Onder de simple uniform hashing aanname is de verwachte waarde van n(j):– E(n(j)) = n/m
Stelling. In een hashtabel waarbij botsingen door chaining worden opgelost, onder de simple uniform hashing aanname, kost een onsuccesvolle zoekactie gemiddeld (1+n/m) tijd
Bewijs. (1) om h(key) te berekenen, en (1+n/m) om lijst af te lopen, want verwachtte lengte van de lijst is n/m.
n/m is de ‘loadfactor’, en wordt met genoteerd
16
Succesvolle zoekacties kosten evenveel (maar lastiger bewijs)
Stelling. In een hashtabel waarbij botsingen door chaining worden opgelost, onder de simple uniform hashing aanname, kost een succesvolle zoekactie gemiddeld (1+n/m) tijd
Bewijs (schets). Neem aan dat elk van de n elementen evenveel kans heeft om gezocht te worden.Gemiddeld zoek je de helft van de lijst T(h(key)) langsElk van de andere n-1 elementen heeft kans 1/m (onafhankelijk) om in
dezelfde lijst te staanDus de verwachtte lengte van T(h(key)) is 1+ (n-1)/m Verwachtte tijd: (1 + (1/2)*(1+(n-1)/m))) = (1+n/m).
(Iets rigoureuzer bewijs in boek.)• Conclusie: als je tabellen gebruikt met n = O(m), dan is de
verwachtte tijd (onder aanname): (1).
17
Hashfuncties: maak van elke key een integer
• Keys kan je zien als bitstrings, en die kan je zien als integers
• Dus, we nemen aan dat de keys integers zijn
• Slechte hashfunctie:– Eerste r bits van de key– Want dan botsen keys met hetzelfde
beginstuk
18
Hash-functies: 2 methoden
• Division method: (“deel-methode”)– h(k) = k mod m
• Multiplication method: (“vermenigvuldig-methode”)– h(k) = m( kA – kA )– Voor constant A met 0 < A < 1– Dus: vermenigvuldig met geschikt getal tussen 0 en 1, neem het deel
“achter de komma”, en vermenigvuldig met m en rond naar beneden af
– Voordeel: hangt niet zo erg af van keuze van m, en dus kan je je tabelgrootte zelf kiezen
– Beste keuze van A??? • Knuth: neem A = ( 5 – 1)/ 2 = 0.61803…
Geval:registratie nummers
en moduli …
Geval:registratie nummers
en moduli …
19
Open addressing
• Alle elementen opslaan in de tabel zelf• Idee:
– Hashfunctie heeft twee argumenten:• Key• Aantal “eerdere pogingen”
• Methode:– Reken eerst h(k,0) uit– Als h(k,0) leeg is, zetten we k op positie h(k,0),– Als er wel wat op h(k,0) staat, dan rekenen we h(k,1) uit– Als h(k,1) leeg is, zetten we k op positie h(k,1)– Anders, kijk naar h(k,2), etc.
20
Open addressing pseudocode en aanname
• Aanname: voor elke key k geldt: elke positie in {0, 1, 2, …, m-1} komt precies 1 keer voor in de “probe sequence” {h(k,0), h(k,1), h(k,2), …, h(k,m)}
• Goede “schudding” van de permutatie gewenst
Hash-Insert(T,k)• i = 0• while h(k,i) niet leeg and i<m do
– i++;• if i<m then
– Zet k op positie h(k,i)• else
– Return foutmelding: Tabel te vol!!!!
21
Zoeken pseudocode
Hash-Search(T,k)• i=0;• repeat
– positie = h(k,i);– if k staat in T(positie) then
• Return extra gegevens op T(positie) etc. Gevonden!
– i++;
• until T[positie] == NIL (lege plek) or i == m• return Element niet gevonden (NIL)
22
Weglaten – het probleem
• Probleem: – “Gewoon” weglaten kan misgaan:
• Stel h(x,0) = h(y,0) = 10
• We slaan x op, op positie 10
• We slaan y op. h(y,0) is vol, dus y gaat naar h(y,1), zeg 20
• Nu laten we x weg
• Nu zoeken we y, en we kijken eerst op 10. Maar… daar staat niks meer!
23
Weglaten – gedeeltelijke oplossing
• Oplossing:– Na weglaten krijg je niet een “gewone” positie, maar een positie met
een speciale DELETED waarde– Zoeken: doorzoeken als je DELETED ziet, totdat je ‘t element vindt
of LEGE positie tegenkomt– Invoegen: zet op de eerst gevonden plaats met LEEG of met
DELETED– Nadeel: weggelaten elementen beïnvloeden nog steeds de tijd van
zoekacties– Techniek: herbouw de hele hash-tabel als er “teveel” deletions
gedaan zijn:• Maak een nieuwe lege tabel• Zet alle “echte” elementen over naar de nieuwe tabel• Gooi de oude tabel weg
• Of gebruik Chaining als je deletions wil doen
24
Keuze van hashfuncties voor open addressing
• Stel h’ is “gewone” hashfunctie (met 1 argument)• Overzicht (details komen):
– Linear probing• h(k,i) = (h’(k)+i) mod m
– Quadratic probing• h(k,i) = (h’(k) + c1 i+ c2 i2) mod m
– Double hashing• h(k,i) = (h’(k) + i* h’’(k)) mod m
25
Linear probing
• h(k,i) = (h’(k)+i) mod m
• Nadeel: primary clustering (“primaire klontvorming”): ophopen van keys bij elkaar als hun hashwaarden in elkaars buurt zitten: lange zoek- en invoegtijden
26
Quadratic probing
• h(k,i) = (h’(k) + c1 i + c2 i2) mod m
• Voor geschikte constantes c1 en c2
• Geen primaire klontvorming, maar wel secundaire klontvorming: alleen gevolgen voor keys met dezelfde hashwaarde – O(1) verwacht…
27
Double hashing
• Stel h’ is een “gewone” hashfunctie (met 1 argument)• Stel h’’ is een functie die altijd elementen in 1 … m-1 geeft die
relatief priem tov m zijn• Double hashing
– h(k,i) = (h’(k) + i* h’’(k)) mod m• Bijvoorbeeld:
– m is macht van 2– h’’ geeft oneven getal
• Of:– Neem m priem, en getal m’ die iets kleiner is dan m, bijv m’=m-1– h’(k) = k mod m;– h’’(k) = 1+ (k mod m’)
• Double hashing benadert de simple uniform hashing aanname het beste
28
Analyse
• Neem weer uniform hashing aanStelling. In een hash-tabel waarbij botsingen door open
addressing worden opgelost, onder de simple uniform hashing aanname, kost een onsuccesvolle zoekactie gemiddeld (1+1/(1-)) tijd, waarbij = n/m < 1.
BewijsDe kans dat er een element op positie h(k,0) staat is . De kans dat we
daarna de tweede keer een bezette positie zien is (n-1)/(m-1), want de 2e plek heeft m-1 mogelijkheden waar nog n-1 elementen zitten. Zo is de kans dat we minstens i keer een positie bekijken met een element erop:
i
m
n
im
in
m
n
m
n
m
n
1
1*...*
2
2*
1
1*
29
Analyse - vervolg• Kans dat je ‘n i-de positie bekijkt is hooguit i-1. Dus verwachtte aantal
posities dat je bekijkt is hooguit
• Verwachtte tijd is O(1+ aantal bekeken posities) = O(1 + 1/(1-n/m)). QED
• Als loadfactor constant is, betekent dit dat de verwachtte tijd (onder aanname over hashfunctie) O(1) is: constant.
• Bijvoorbeeld: als tabel voor 50% vol: 1/(1-0.5) = 2 posities; als tabel voor 90% vol: 1/(1-0.9) = 10 posities die gemiddeld bekeken worden.
1
1
01
1
j
jm
i
i
30
Toevoegen: analyse
Stelling. In een hashtabel waarbij botsingen door open addressing worden opgelost, onder de simple uniform hashing aanname, kost een insertion gemiddeld (1+1/(1-)) tijd, waarbij = n/m < 1.
Bewijs: we doen eerst een onsuccesvolle zoekactie op het in te voegen element, en dan plaatsen we het element. Dus, de vorige analyse geldt.
31
Analyse van succesvolle zoekactie
Stelling. In een hashtabel waarbij botsingen door open addressing worden opgelost, onder de simple uniform hashing aanname, kost een succesvolle zoekactie gemiddeld (1+(1/) ln (1/(1-)) tijd, waarbij =n/m < 1.
Bewijs. Stel k is het (i+1)e element dat we invoegen.Als we ‘m zoeken, kunnen we alleen het 1e, 2e, …, ie element dat
ingevoegd is tegenkomen, want k kan alleen met hun botsen tijdens de insertion van k.
Verwachtte aantal bekeken posities bij zoeken van k is daarom hooguit 1/(1-i/m) = m / (m-i).
Gemiddeld over 1e, 2e, …, ne element is:
Hierbij nemen we aan dat elk element dezelfde kans heeft om gezocht te worden; details zie boek.
1
0 1
1ln
1...*
1 n
i im
m
n
32
Succesvolle zoekacties
• Voor constante loadfactor: succesvol zoeken kost O(1) tijd
• Bijvoorbeeld: als tabel 50% vol, dan 1.387 posities bekeken; 90% vol geeft 2.559.
• Dus: neem bij hashtabellen de tabel groot genoeg, om e.e.a. snel genoeg te laten verlopen.
33
Techniek in praktijk
• We beginnen met een niet al te grote tabel• Als de load factor te groot wordt (bijv. meer
dan 0.8) dan verdubbelen we de tabelgrootte– Neem een twee keer zo groot array– Zet alle elementen uit de hashtabel in de nieuwe
array– Gebruik vanaf nu het nieuwe array– Herhalen als de load factor weer te groot wordt
34
Voordelen en nadelen
• Hashtabellen hebben een slecht “slechtste geval”, maar zijn verwacht, en in de praktijk, heel snel
• Je moet een hashfunctie maken, iets doen met deletions als je open addressing gebruikt, iets doen met volle tabellen (herbouw), …
• Zoekbomen hebben meer functies: minimum, opvolger, … Als je dit soort functies wilt, is een zoekboom beter. Zo niet, dan is hashing in de praktijk meestal sneller.
35
Conclusies
• Hashtabellen: snel en praktisch• Chaining• Open adressing: het probleem zijn de deletions• Je moet goede hashfuncties maken• De tabel moet niet te vol worden, want dan wordt de
hashing te langzaam• In Java: HashMap
– Iteration over alle elementen gaat alle tabelentries langs en slaat de lege over.
– Je kan de initiële capaciteit zetten (beïnvloedt efficiëntie)
• In C#: Hashtable