Algorithmen und Datenstrukturen SS09. Foliensatz 12. Michael Brinkmeier. Technische Universität Ilmenau Institut für Theoretische Informatik

Transkript

1 Foliensatz 12 Michael Brinkmeier Technische Universität Ilmenau Institut für Theoretische Informatik Sommersemester 2009 TU Ilmenau Seite 1 / 98 Hashing TU Ilmenau Seite 2 / 98

2 Wörterbücher Sei U ein Universum von Schlüsseln und R eine Menge von Werten. Wie bereits gesehen, entsprechen Wörterbücher partiellen Abbildungen von U nach R. Alternativ können wir sagen, dass ein Wörterbuch f eine Abbildung f : S R von einer Teilmenge S U des Universums in den Wertebereich ist. TU Ilmenau Seite 3 / 98 Wörterbücher Suchbäume implementieren Wörterbücher auf einem total geordneten Universum U. Jede Operation benötigt in allen vorgestellten Varianten Zeit O(log n), wobei n die Anzahl der Schlüssel ist. Frage Kann man Wörterbücher auf einem (eventuell nicht geordneten) Universum U implementieren, so dass jede Operation im Durchschnitt Zeit O(1) benötigt, und damit unabhängig von der Anzahl der Schlüssel ist? Antwort: JA! TU Ilmenau Seite 4 / 98

3 Die Idee Sei f : S R mit S U gegeben und m eine natürliche Zahl und [m] := {0,...,m 1}. Wir speichern die Paare (s, f (s)) in einer Tabelle H[0...m 1] von Objekten in R. Dazu verwenden wir eine Abbildung h: U [m], die zu jedem Schlüssel x aus U einen Index h(x) berechnet. Diese Abbildung heisst Hashfunktion und das Array H heisst Hashtabelle. Im Idealfall können wir dann das Paar (x, f (x)) in H[h(x)] speichern. TU Ilmenau Seite 5 / 98 Ein Beispiel U = {a,...,z} 3, d.h. die Schlüssel sind alle Wörter aus mindestens 3 Kleinbuchstaben. h: U {0,...,12} sei nun definiert als h(c 1 c 2 c r ) = num(c 3 ) mod 13, wobei num(a) = 0, num(b) = 1,...,num(z) = 25. TU Ilmenau Seite 6 / 98

4 Ein Beispiel h(c 1 c 2 c r ) = num(c 3 ) mod 13, x f (x) num(c 3 ) h(x) januar februar maerz april mai juni juli august september oktober november dezember TU Ilmenau Seite 7 / 98 Ein Beispiel h(c 1 c 2 c r ) = num(c 3 ) mod 13, Im Allgemeinen führt dieser Ansatz zu Kollisionen. i (x, f (x)) 0 (januar, 31), (juni, 30) 1 (februar,28) 2 (september, 30) 3 (maerz, 31), (april, 30) (august, 30), (oktober, 31) 7 8 (mai, 31), (november, 30) (juli, 31) 12 (dezember, 31) TU Ilmenau Seite 8 / 98

5 Perfekte Hashfunktionen Im Idealfall ist die Hashfunktion für f : S R auf S injektiv, d.h. für jedes i [m] existiert höchstens ein Schlüssel x S mit h(x) = i. Sprechweise Falls h auf S injektiv ist, sagen wir h ist perfekt für S. Im Falle einer perfekten Hashfunktion h für S können wir somit das Paar (x, r) einfach in H[h(x)] speichern. In dieser Situation wäre lookup(x) einfach 1 Berechne i = h(x) 2 Prüfe ob in H[i] ein Paar der Form (x, r) steht. 3 Falls ja, gebe r aus, sonst. TU Ilmenau Seite 9 / 98 Kollisionen Von einer Kollision reden wir, wenn zwei Schlüssel x, y S existieren mit x y aber h(x) = h(y). In der Praxis sind Kollisionen leider fast unvermeidlich. Um sie zu umgehen müsste man die Hashfunktion passend zu S konstruieren (z.b. Indices für Datenbanken). Ein Ziel ist es daher die Zahl der Kollisionen mit vertretbarem Aufwand relativ klein zu halten. TU Ilmenau Seite 10 / 98

6 Offenes Hashing Bevor wir uns mit geeigneten Hashfunktionen beschäftigen, betrachten wir Ansätze um mit Kollisionen umgehen zu können. Eine Lösung ist es sicherlich, dass eine Speicherzelle H[i] der Hashtabelle beliebig viele Schlüssel-Wert-Paare (x, r), nämlich alle mir h(x) = i, aufnehmen kann. Diese Herangehensweise wird offenes Hashing genannt. TU Ilmenau Seite 11 / 98 Hashing mit verketteten Listen Eine Einfache Implementierung von offenem Hashing erhält man, wenn die Einträge der Hashtabelle H[0... m 1] einfach verketteten Listen H 0,...,H m 1 sind. Dabei enthält H j alle Paare (x, r) mit h(x) = j. TU Ilmenau Seite 12 / 98

7 Hashing mit verketteten Listen H 0 : (juni, 30) (januar, 31) H 12 : (februar, 28) H 12 : (september, 30) H 0 : (maerz, 31) (april, 30) H 4 : H 5 : H 0 : (august, 30) (oktober, 31) H 7 : H 0 : (mai, 31) (november, 30) H 9 : H 10 : H 11 : (juli, 31) H 12 : (dezember, 31) TU Ilmenau Seite 13 / 98 Hashing mit verketteten Listen empty(m): Erzeugt eine Array H[0... m 1] mit m NULL-Zeigern und legt die Hashfunktion h: U [m] fest. Kosten: Θ(m). insert(x, r): Berechne j = h(x) Suche den Schlüssel x in der Liste H j. Falls er existiert, ersetze den alten Wert durch r. Sonst füge (x, r) in die Liste H j ein. Kosten: abhängig von der Anzahl der Schlüsselvergleiche Annahme: Ein Schlüsselvergleich benötigt Zeit O(1) Erfolglose Suche: H j Vergleiche Erfolgreiche Suche: Zwischen 1 und H j Vergleiche TU Ilmenau Seite 14 / 98

8 Hashing mit verketteten Listen lookup(x): Berechne j = h(x) Suche den Schlüssel x in der Liste H j. Falls er existiert, gebe r zurück. Sonst gebe zurück. Kosten: Wie bei insert delete(x): Berechne j = h(x) Suche den Schlüssel x in der Liste H j. Falls er existiert, lösche ihn. Sonst tue nichts. Kosten: Wie bei insert TU Ilmenau Seite 15 / 98 Hashing mit verketteten Listen Ziel Analysiere die erwarteten Kosten für insert, delete und lookup. Dies entspricht der Analyse der erwarteten Anzahl der Schlüsselvergleiche. Um die erwartete Anzahl von Schlüsselvergleichen berechnen zu können, benötigen wir einen Wahrscheinlichkeitsraum Ω, der uns die Hashfunktion und die Schlüssel erzeugt. Allerdings wollen wir Ω zur Zeit noch nicht festlegen, sondern nehmen nur an, dass wir die folgende (abgeschwächte) Uniuformitätsannahme UF 2 über die rersultierenden Hashwerte machen können: Uniformitätsannahme UF 2 Für je zwei Schlüssel x y in U gilt: P(h(x) = h(z)) 1 m. TU Ilmenau Seite 16 / 98

9 Die erwartete Zahl von Schlüsselvergleichen Szenario Die Menge S = {x 1,..., x n } ist in der Hashtabelle H mit Hashfunktion h gespeichert. Es soll nach y U gesucht werden. α = n m sei der aktuelle Auslastungsfaktor. Für alle x, z U definieren wir die folgenden Indikatorvariablen: { 0 falls h(x) h(z) Y x,z := 1 falls h(x) = h(z). Nach (UF 2 ) gilt: E(Y x,z ) = P(h(x) = h(z)) 1 m. TU Ilmenau Seite 17 / 98 Erfolglose Suche Fall 1: y S, d.h. die Suche bleibt erfolglos. Die Anzahl der Schlüsselvergleiche entspricht der Länge der zu durchlaufenden Liste H h(y). H h(y) = {x S h(x) = h(y)} = x S Y x,y. Für die erwartete Listenlänge gilt somit E( H h(y) ) = x S E(Y x,y ) UF 2 x S 1 m = n m = α. TU Ilmenau Seite 18 / 98

10 Erfolgreiche Suche Fall 2: y S, d.h. die Suche ist erfolgreich. In diesem Fall hängt die Anzahl der Schlüsselvergleiche von der Position des Schlüssels y in der Liste H h(y) ab. Wir nehmen (ohne Beschränkung der Allgemeinheit) an, dass die Schlüssel in der Reihenfolge x 1,..., x n eingefügt werden und dabei an das Listenende gesetzt werden. Im Fall y = x i wird y mit genau i k=1 Y xk,y Listenelementen verglichen (denen in H h(y), die vor x i eingefügt wurden). TU Ilmenau Seite 19 / 98 Erfolgreiche Suche Wir mitteln die Anzahl der Schlüsselvergleiche über den Schlüsseln in S. Damit ergibt sich die mittlere Anzahl der Schlüsselvergleiche als n i P(y = x i ) Y xk,y = 1 n i=1 k=1 n i Y xk,x i = n i=1 k=1 1 k<i n Y xk,x i Wegen UF 2 gilt somit für die erwartete Anzahl E(Y ) der Schlüsselvergleiche E(Y ) = n m = ( ) n n 1 (n 1) = m 2m < 1 + α 2. 1 k<i n TU Ilmenau Seite 20 / 98

11 Hashing mit verketteten Listen Satz Beim Hashing mit verketteten Listen gilt unter der Annahme von UF 2 folgendes: Die erwartete Anzahl von Schlüsselvergleichen bei erfolgoser Suche ist höchstens α. Die erwartete mittlere Anzahl (gemittelt über die Schlüssel) von Schlüsselvergleichen bei erfolgreicher Suche ist höchstens 1 + α 2. Der erwartete Zeitbedarf für eine Suche ist O(1 + α). Wenn eine Konstante α 1 existiert mit α α 1, dann ist die erwartete Zeit für eine erfolgreiche Suche O(1). TU Ilmenau Seite 21 / 98 Hashing mit verketteten Listen Frage Wie erreicht man α α 1 bei wachsender, am Anfang unbekannter Schlüsselzahl? Antwort Mittels einer Verdoppelungsstrategie TU Ilmenau Seite 22 / 98

12 Die Verdoppelungsstrategie Wir beginnen mit einer festen Anfangsgröße m 0. Die aktuelle Tabellengröße sei m. In der Variable load wird mitgeführt, wieviele verschiedene Einträge die Hashtabelle gerade enthält (d.h. die Summe der Längen der einzelnen Listen). Wenn insert(x, r) dazu führt, dass load den Wert α 1 m überschreitet (d.h. die Auslastung steigt über α 1 ), dann wird folgendes getan: Erzeuge eine neue Tabelle H mit 2m Einträgen. Erzeuge eine neue Hashfunktion h : U [2m]. Übertrage die Einträge der alten Hashtabelle in die neue. Dabei wird zum Einfügen natürlich h benutzt. Dabei fügen wir die Werte am Anfang der Listen (ohne Suche) ein. Bennene H und h zu H und h um. TU Ilmenau Seite 23 / 98 Die Verdoppelungsstrategie Lemma Sei α 1 fest und die verwendeten HAshfunktionen erfüllen (UF 2 ). Ist die Anfangsgröße m 0 1 α 1, so gilt bei Anwendung der Verdoppelungsstrategie stets α = n m α 1 Beweis Wir beweisen die Behauptung per Induktion über n. IA: n = 1 Nach dem Einfügen des ersten Elements gilt α = 1 m 0 α 1. IV: Enthält die Hashtabelle n Elemente, so gilt α α TU Ilmenau Seite 24 / 98

13 Die Verdoppelungsstrategie Beweis (Fortsetzung) IS: Enthält die Hashtabelle nach einer Einfügung n + 1 Elemente, so enthielt sie vorher n Elemente und es galt nach IV n m α 1. Gilt außerdem n+1 m α 1, so behält die Tabelle ihre Größe und die Behauptung gilt. Gilt jedoch n+1 m > α 1, so wird die Hashtabelle vergrößert und der neue Auslastungsfaktor ist α = n+1 2m. Sollte nun weiterhin α 1 < α = n+1 2m gelten, so ergibt sich und somit n < 1. Widerspruch! n m < n+1 2m Damit ist n+1 2m α 1 sichergestellt. TU Ilmenau Seite 25 / 98 Die Verdoppelungsstrategie Korollar Sei α 1 fest und erfüllen alle verwendeten Hashfunktionen (UF 2 ), dann ist die erwartete Anzahl der Schlüsselvergleiche für die erfolglose bzw. erfolgreiche Suche α 1 bzw. 1 + α 1 2. TU Ilmenau Seite 26 / 98

14 Die Verdoppelungsstrategie Durch eine ähnliche Analyse wie bei der Arrayimplementierung von Stacks, erhält man außerdem Satz Sei α 1 fest. Wenn die verwendeten Hashfunktionen (UF 2 ) erfüllen, dann gilt Folgendes für das skizzierte Verdoppelungsverfahren für das Hashing mit verketteten Listen: Die Gesamtkosten für sämtliche Verdoppelungen sind durch O(ˆn) (im schlechtesten Fall) beschränkt. Dabei ist ˆn die maximale Anzahl der jemals gleichzeitig in der Hashtabelle vorhandenen Schlüssel. Der Gesamtplatzbedarf ist O(ˆn). TU Ilmenau Seite 27 / 98 Kriterien für die Wahl von Hashfunktionen Kriterien für die Wahl von Hashfunktionen Zeit für die Auswertung Die Funktion muss schnell berechnet werden können. Kollisionswahrscheinlichkeit Unter realistischen Annahmen oder gar keinen Annahmen über die Schlüsselmenge S, soll die Zahl der Kollisionen möglichst gering sein. Effizientes Generieren einer neuen Hashfunktion benötigt bei der Verdoppelungsstrategie Platzbedarf für die Speicherung von h Sollte klein sein gegenüber n! Die Geschwindigkeit der Auswertung hängt vom Format der Schlüssel ab. TU Ilmenau Seite 28 / 98

15 Divisionsrestmethode Sind die Schlüssel natürliche Zahlen, d.h. U N so bietet sich die Divisionsrestmethode an: h(x) = x mod m Vorteile: Sehr einfach Recht effizient berechenbar Nachteile: Unflexibel Bei strukturierten Schlüsselmengen (z.b. aus Strings übersetze Schlüssel) besteht ein erhöhtes Kollisionsrisiko Nur für Primzahlen m relativ sicher. Vorsichtsmaßnahme: m 2 k 20 für alle Zweierpotenzen 2 k. Für Produktivsysteme ist diese Form der Hashfunktion nicht sehr zu empfeheln. TU Ilmenau Seite 29 / 98 Multiplikationsmethode Idee Sei U N. Für 0 < θ < 1 (ϑ Q) sei h(x) = ((ϑ x) mod 1) m. Dabei ist (ϑ x) mod 1 = (ϑ x) ϑ x der gebrochene Anteil von ϑ x. TU Ilmenau Seite 30 / 98

16 Ein Beispiel h(x) = ((ϑ x) mod 1) m Sei θ = 1 2 ( 5 1 ) 0, und m = 100. h(10) = (6, mod 1) 100 = 0, = 18 h(11) = (6, mod 1) 100 = 0, = 79 h(11) = (7, mod 1) 100 = 0, = 41 Man kann zeigen, dass mit diesem θ aufeinanderfolgende Schlüssel x, x + 1, x + 2,...,x + q 1 sehr gut in [m] verteilt werden. TU Ilmenau Seite 31 / 98 Die Diskrete Version der Multiplikationsmethode Bei der vorgestellten Multiplikationsmethode werden Fließkommazahlen benutzt. Dies kann aber vermieden werden. Sei U = [2 k ], m = 2 l, a [2 k ] ungerade und h a (x) = (a x mod 2 k )div 2 k l. Die Ausdrücke a x mod 2 k und a 2 k x mod 1 entsprechen beide den letzten k Bits von a x. Damit entspricht die obige Hashfunktion der Multiplikationsmethode mit θ = a 2 k. Insgesamt lässt sich h sehr effizient durch eine Multiplikation von zwei k-bit Zahlen und einigen Shiftoperationen auswerten. a k Bits x k Bits = a x 2k Bits l Bits h(x) TU Ilmenau Seite 32 / 98

17 Wörter als Schlüssel Definition (Alphabet) Ein Alphabet Σ ist eine endliche nichtleere Menge. Die Menge Seq(Σ) der endlichen Folgen von Elementen aus Σ ist die Menge der Wörter über Σ. Ein einzelnes Element ist ein Wort. Beispiel Σˆ=ASCII-Alphabetˆ={0, 1} 8ˆ={0, 1,..., 255}. Wir nehmen im Folgenden an, dass die Schlüssel Wörter über einem Alphabet Σ sind, d.h. x = (c 1,...,c r ) = c 1... c r mit c 1,...,c r Σ. Es ist natürlich immer möglich die Zeichen aus Σ zu ordnen, was eine Bijektion ergibt: num: Σ {0,..., Σ 1}. TU Ilmenau Seite 33 / 98 Wörter als Schlüssel Eine nicht sehr empfehlenswerte Möglichkeit ist damit die Transformation eines Schlüssels x in eine Zahl ˆx = n(x) und dann diese Zahl als Argument für die Hashfunktion zu benutzen. Beispiel h(c 1...c r ) = num(c 3 ) mod 13, d.h. ˆx = num(c 3 ) h(januar) = num(n) mod 13 = 13 mod 13 = 0 h(juni) = num(n) mod 13 = 13 mod 13 = 0 Kollisionen mit n(x) = n(y) sind nicht auflösbar. Wenn n aber injektiv ist, ist h(ˆx) in der Regel nur ineffizient auswertbar. TU Ilmenau Seite 34 / 98

18 Lineare Funktionen Besser wäre es, wenn man die Hashfunktion an das Schlüsselformat anpasst. m = p sei eine Primzahl mit p > Σ, also 0 num(c) < p für alle c Σ. Man wähle Koeffizienten a 1,..., a r [p] und setze ( r ) h(c 1... c r ) = a i num(c i ) i=1 mod p. Wenn man nach jeder Multiplikation und Addition modulo m rechnet, rechnet man nur mit Zahlen < m 2 Sehr effizient Nachweisbar gutes Verhalten, wenn die Koeffizienten zufällig aus [p] gewählt wurden. TU Ilmenau Seite 35 / 98 Geschlossenes Hashing TU Ilmenau Seite 36 / 98

19 Gechlossenes Hashing Bim geschlossenen Hashing (aka offene Adressierung), wird in jeder Zelle der Hashtabelle nur ein Eintrag gespeichert. Da Kollisionen fast unvermeidlich sind, kann damit die Adresse eines Eintrages in der Hashtablle nicht nur von der Hashfunktion h abhängen. Daher der Begriff offene Adressierung. Frage Wie wählt man beim Einfügen einen leeren Platz und wie kann man bei lookup einen eingefügten Eintrag zuverlässig wieder finden? Antwort Sondieren TU Ilmenau Seite 37 / 98 Lineares Sondieren Die wohl einfachste Variante des Sondierens ist das lineare Sondieren. Dabei geht man bei insert(x) folgendermaßen vor: 1 Mittels der Hashfunktion h berechnet man einen Tabellenplatz i = h(x). 2 Ist H[i] leer, so wird x in H[i] eingefügt. 3 Ansonsten wird i = (i + 1) mod m und man geht wieder zu Schritt 2. TU Ilmenau Seite 38 / 98

20 Ein Beispiel Die Schlüssel sind die Monatsnamen. h(x) = (num(c 3 ) + 4) mod 13. 0: November (12) 1: 2: Juli (2) 3: Dezember (3) 4: Januar (4) 5: Februar (5) 6: Juni (4) 7: September (6) 8: Maerz (8) 9: April (8) 10: August (10) 11: Oktober (10) 12: Mai (12) h(september) h(november) h(oktober) h(april) h(juni) = TU Ilmenau Seite 39 / 98 Sondieren Diese Idee kann verallgemeinert werden. Idee Anstatt nur eines Hashwertes h(x) für einen Schlüssel x, verwendet man viele Hashwerte h(x, 0), h(x, 1), h(x, 2),... Beim Einfügen werden die Zellen in dieser Reihenfolge durchsucht, bis eine leere Zelle gefunden wird. Im Allgemeinen verwendet das geschlossene Hashing eine Funktion h: U N [m] die jedem Schlüssel x und jeder Sondierungsweite i einen Index h(x, i) zuordnet. TU Ilmenau Seite 40 / 98

21 Lineares Sondieren Im Falle des linearen Sondierens ist h(x, i) = (h(x) + i) mod m TU Ilmenau Seite 41 / 98 Einfügen mit Sondieren insert(x) Gegeben: Schlüssel x U und Wert r Hashtabelle H[0...m 1] und Hashfunktion h: U N [m] i = 0; while H[h(x, i)] nicht leer und key(h[h(x, i)]) x do i = i + 1; H[h(x, i)] = (x, r) ; TU Ilmenau Seite 42 / 98

22 Suche mit Sondieren lookup(x) Gegeben: Schlüssel x U Hashtabelle H[0...m 1] und Hashfunktion h: U N [m] i = 0; while H[h(x, i)] nicht leer und key(h[h(x, i)]) x do i = i + 1; if key(h[h(x, i)]) == x then return data(h[h(x, i)]); if H[h(x, i)] leer then return ; TU Ilmenau Seite 43 / 98 Suche mit Sondieren Es bleibt zu zeigen, dass lookup(x) korrekt ist. Offensichtlich werden für i = 0, 1, 2,... die gleichen Felder durchsuscht, wie beim Einfügen von x. Da kein Element bewegt oder gelöscht wird, wird x früher oder später gefunden, falls es vorhanden ist. Denn alle Einträge in der Sondierungsfolge müssen bereits vor dem Einfügen von x besetzt gewesen sein und sind es weiterhin. Falls eine leere Zelle erreicht wird, kann x noch nicht eingefügt worden sein, denn ansonsten hätten wir es bereits gefunden oder es wäre in die leere Zelle eingefügt worden. TU Ilmenau Seite 44 / 98

23 Suche mit Sondieren Frage Was passiert, wenn die Tabelle vollständig gefüllt ist? Dann könnte lookup in eine Endlosschleife geraten. Das Problem kann auf verschiedene Arten gelöst werden: Eine Zelle muss stets frei bleiben und jede Sondierung trifft früher oder später auf diese oder eine andere leere Zelle. Man gestaltet die Sondierung so, dass man nach jeweils l Schritten alle möglichen Zellen abgesucht hat. Dann weiß man spätestens nach dem Sondieren von l Zellen, dass der Schlüssel nicht vorhanden ist. Das lineare Sondieren ermöglicht beide Ansätze. Die freie Zelle ist dabei beliebig. Nach m Schritten, erreicht man wieder die Ausgangszelle. TU Ilmenau Seite 45 / 98 Die allgemeine Unifomitätsannahme Ähnlich zu (UF 2 ) können wir eine deutlich stärkere Annahme über den Wahrscheinlichkeitsraum für das Hashing machen, die bei der Analyse des linearen Sondierens hilft. Die Uniformitätsannahme (UF ) Sei S = {x 1,..., x n } für ein n N. Die Werte h(x 1 ),..., h(x n ) sind rein zufällig, d.h. jeder der m n möglichen Wertevektoren (j 1,..., j n ) [m] n kommt mit derselben Wahrscheinlichkeit 1 m n als (h(x 1 ),..., h(x n )) vor. TU Ilmenau Seite 46 / 98

24 Lineares Sondieren Satz Beim linearen Sondieren in einer Tabelle der Größe m mit Schlüsselmenge S = {x 1,...,x n } und Auslastungsfaktor α = n m gilt unter der Annahme (UF ): Die erwartete Anzahl von Schlüsselvergleichen bei erfolgloser Suche nach y S ist 1 ( ) (1 α) 2. Die erwartete über x 1,..., x n gemittelte Anzahl von Schlüsselvergleichen bei erfolgreicher Suche nach y S ist 1 ( ). 2 1 α Insbesondere hängt die erwartete Anzahl von Schlüsselvergleichen nur von α und nicht von n und m ab. TU Ilmenau Seite 47 / 98 Die erwartete Anzahl der Vergleiche 200 erfolglose Suche erfolgreiche Suche TU Ilmenau Seite 48 / 98

25 Die erwartete Anzahl der Vergleiche α 1 2 ( erfolglos (1 α) 2 ) 1 2 erfolgreich ( ) α 0,5 2,5 1,5 0,6 3,625 1,75 0,7 6,06 2,16 0,75 8,5 2,5 0, ,9 50,5 5,5 0,95 200,5 20 Fazit Bei einer zu 90% gefüllten Tabelle wird die erfolglose Suche schon recht teuer, was in vielen Anwendungen nicht tolerierbar ist. α 0, 7 liefert jedoch akzeptable Kosten. TU Ilmenau Seite 49 / 98 Die erwartete Anzahl der Vergleiche Fakt Lineares Sondieren passt perfekt zu Cache-Architekturen! Es wird stets ein ganzer Abschnitt der Hashtabelle in den Cache geladen, der anschließend schnell durchsucht werden kann. Damit ist das lineare Sondieren in der Praxis relativ schnell. Um einen hinreichend kleinen Auslastungsfaktor α 0 zu garantieren, bietet sich die Verdoppelungsstrategie an. Dabei wird, wie bereits oben beschrieben, die Tabelle verdoppelt, sobald der Auslastungsfaktor α = n/m die gegebene Schranke α 0 überschreitet. Empfehlung Lineares Sondieren mit einer guten universellen Hashklasse (kommt später). Man sollte nicht auf die Zufälligkeit von S vertrauen! TU Ilmenau Seite 50 / 98

26 Sondieren Wie bereits oben gesehen, ist es günstig, wenn das Sondieren alle Zellen erreicht, d.h. Annahme ( ) Für jedes x U erreicht die Sondierungssequenz (h(x, 0), h(x, 1),..., h(x, m 1)) jede Zelle der Tabelle, d.h. (h(x, 0), h(x, 1),..., h(x, m 1)) ist eine Permutation von [m]. Gilt ( ) und ist in H stets mindestens eine Zelle leer, dann endet jede erfolglose Suche in einer leeren Zelle. Alternativ kann, wenn ( ) gilt, die Sondierung nach m Runden abgebrochen werden. Das lineare Sondieren h(x, i) = (h(x) + i) mod m erfüllt ( ). TU Ilmenau Seite 51 / 98 Quadratisches Sondieren h: U [m] sei eine beliebige Hashfunktion. Beim Quadratischen Sondieren springt man abwechselnd vor und zurück. Außerdem ändert man in jedem zweiten Sprung die Sprungweite auf die nächst höhere Quadratzahl ab. h(x, 0) = h(x) h(x, 1) = (h(x) + 1) mod m h(x, 1) = (h(x) 1) mod m h(x, 1) = (h(x) + 4) mod m h(x, 1) = (h(x) 4) mod m h(x, 1) = (h(x) + 9) mod m h(x, 1) = (h(x) 9) mod m h(x, i)= ( h(x) + ( 1) i+1 k/2 2) mod m. TU Ilmenau Seite 52 / 98

27 Quadratisches Sondieren Lemma Ist m eine Primzahl mit m mod 4 = 3, dann ist {h(x, i) 0 i < m} = [m], d.h. ( ) gilt. Beispiel m = 19 und h(x) = 18: 8, 9, 7, 12, 4, 17, 18, 5, 11, 14, 2, 6, 10, 0, 16, 15, 1, 13, 3, Beobachtung Die Erfahrung zeigt, dass das quadratische Sondieren sich sehr gut verhält, sofern h gut verteilt und der Auslastungsfaktor 0, 9 ist. TU Ilmenau Seite 53 / 98 Doppel-Hashing Idee Man beutzt zwei (unabhängige) Hashfunktionen h 1 : U [m] und h 2 : U [m 1] und setzt h(x, i) := (h 1 (x) + i (1 + h 2 (x))) mod m. D.h. h 1 (x) gibt den Startwert und h 2 (x) die Schrittweite an. Beispiel m = 13, h 1 (x) = 3 und h 2 (x) = 7 liefert die Sondierungsfolge 3, 10, 4, 11, 5, 12, 6, 0, 7, 1,8, 2, 9. TU Ilmenau Seite 54 / 98

28 Doppel-Hashing h(x, i) := (h 1 (x) + i (1 + h 2 (x))) mod m. Lemma Wenn m eine Primzahl ist, dann gilt für das Doppel-Hashing: Beweis {h(x, i) 0 i < m} = [m]. Sei z = 1 + h 2 (x) die Schrittweite zu x. Damit gilt 1 z m 1. Wenn h(x, i) = h(x, j) für 0 i, j < m gilt, dann ist (h 1 (x) + i z) mod m = (h 1 (x) + j z) mod m und somit (i j) z mod m = TU Ilmenau Seite 55 / 98 Doppel-Hashing Beweis (Fortsetzung) (i j) z mod m = 0. Da m eine Primzahl ist, folgt daraus, dass entweder z oder (i j) von m geteilt wird. Da z < m ist, muss m in Teiler von (i j) sein. Da aber i, j < m, muss i = j gelten. TU Ilmenau Seite 56 / 98

29 Doppel-Hashing-Variante Falls m = 2 l und h 1 : U [m] und h 2 : U [m/2], dann ist h(x, i) = h 1 (x) + i (2 h 2 (x) + 1) eine gute Sondierungsstrategie, die alle Tabelleneinträge innerhalb von m Schritten erreicht d.h. sie erfüllt ( ). Diese Hashfunktion lässt sich auf einfache Art nur mittels Addition, Shifts und XOR errechnen. TU Ilmenau Seite 57 / 98 Uniformes Sondieren TU Ilmenau Seite 58 / 98

30 Uniformes Sondieren Man kann beweisen, dass wenn h 1 (x) und h 2 (x) für x S rein zufällig sind, sich das Doppel-Hashing sehr gut, nämlich im wesentlichen wie Uniformes Sondieren verhält. Uniformes Sondieren / Ideales Hashing (US) Man spricht vom Uniformen Sondieren, wenn (h(x, 0), h(x, 1),..., h(x, m 1)) eine rein zufällige Permutation von [m] ist, unabhängig für jedes x U. (US) ist keine Methode, sondern eine Annahme über den Wahrscheinlichkeitsraum in dem die Hashfunktionen, die Schlüssel und alles weitere gewählt wird. TU Ilmenau Seite 59 / 98 Uniformes Sondieren Effekt x 1,...,x n seien bereits gespeichert und y komme hinzu. Ganz egal, was die Hashwerte von x 1,..., x n und die Werte h(y, 0),..., h(y, i 1) sind, h(y, i) nimmt jeden Wert j [m] \ {h(y, 0),...,h(y, i 1)} mit derselben Wahrscheinlichkeit 1/(m i) an. TU Ilmenau Seite 60 / 98

31 Uniformes Sondieren Im Folgenden sei stets: n die Anzahl der Schlüssel in H[0...m 1] α = n m der Auslastungsfaktor. T m,n die Anzahl der Sondierungen bei erfolgloser Suche C m,n = E(T n,m ) T m,n die Anzahl der Sondierungen bei erfolgicher Suche C m,n = E(T n,m ) TU Ilmenau Seite 61 / 98 Uniformes Sondieren Satz (Erfolglose Suche) Unter der Annahme (US), d.h. das Sondieren ist uniform, gilt: C m,n = m + 1 m + 1 n = 1 1 n m+1 < 1 1 n m = 1 1 α. Wenn α konstant ist und n und m gegen unendlich gehen, dann gilt C m,n 1 α. TU Ilmenau Seite 62 / 98

32 Uniformes Sondieren Beweis x 1,...,x n seien die gespeicherten Schlüssel. Da die Suche erfolglos ist, wird y {x 1,...,x n } gesucht. Wir unterscheiden zwei Fälle: 1. Fall: H[h(y, 0)] ist leer nach (US) nimmt h(y, 0) jeden der Werte in [m] mit der gleichen Wahrscheinlichkeit 1 m an. Da außerdem m n Fächer frei sind, ergibt sich Wahrscheinlichkeit für diesen Fall als m n m. Lediglich eine Sondierung ist nötig.... TU Ilmenau Seite 63 / 98 Uniformes Sondieren Beweis (Fortsetzung) Fall 2: H[h(y, 0)] ist nicht leer Die Wahrscheinlichkeit für diesen Fall ist 1 m n m = n m. Die Gesamtzahl der Sondierungen ist 1 + T m 1,n 1, denn es folgt eine Suche in m 1 Plätzen, von denen n 1 besetzt sind. { Damit gilt T m,n 1 mit Wahrscheinlichkeit m n = m 1 + T m 1,n 1 mit Wahrscheinlichkeit n m Für den Erwartungswert ergibt sich somit die folgende Rekursionsformel für 0 n < m: { C m,n = 1 falls n = 0 + n m (1 ) + C m 1,n 1 falls n 1 m n m... TU Ilmenau Seite 64 / 98

33 Uniformes Sondieren Beweis (Fortsetzung) C m,0 = 1 C m,1 = m 1 m + 1 m (1 + 1) = m + 1 m C m,2 = m 2 m + 2 m (1 + m m 1 ) = m 1 = m + 1 m 1 C m,3 = m 3 m + 3 m (1 + m m 2 ) = m 2 = m + 1 m 2... Mittels vollständiger Induktion erhält man C m,n = m + 1 m + 1 n. TU Ilmenau Seite 65 / 98 Uniformes Sondieren Satz (Erfolgreiche Suche) Unter der Annahme (US), d.h. das Sondieren ist uniform, gilt: C m,n < 1 ( ) 1 α ln 1 α Wobei über S gemittelt wird. TU Ilmenau Seite 66 / 98

34 Unifromes Sondieren Beweis Der Suchaufwand für x i ist gleich dem Einfügeaufwand für x i, denn es müssen gleich viele Sondierungen vorgenommen werden. Der Einfügeaufwand wiederrum entspricht dem Aufwand für eine erfolglose Suche, wenn x i noch nicht eingefügt worden ist. Also muss über die C m,0, C m,1,..., C m,n 1 gemittelt werden: C m,n = 1 n n 1 i=0 = m + 1 n C m,i ( m+1 m n+2 ) 1 i = m + 1 n = 1 n n 1 i=0 m + 1 m + 1 i (H m+1 H m n+1 ).... TU Ilmenau Seite 67 / 98 Uniformes Sondieren Beweis (Fortsetzung) C m,n = m + 1 n (H m+1 H m n+1 ) Ähnlich zur Abschätzung für H n über die Ober- und Untersumme, kann man nun zeigen, dass H m+1 H m n+1 gilt. m+1 m+1 n ( ) m + 1 = ln(m + 1) ln(m n + 1) = ln m n + 1 Das ergibt C m,n m + 1 n ( ) 1 ln 1 n. m+1... TU Ilmenau Seite 68 / 98

35 Uniformes Sondieren Beweis (Fortsetzung) Betrachtet man die( Funktion f (x) = 1 x ln ) 1 1 x im Intervall [0, 1], sieht man dass sie streng monoton steigt. Damit gilt n f ( m + 1 ) < f ( n m ) = f (α), und somit C n,m < 1 α ( ) 1. 1 α ( 1 x ln 1 1 x ) TU Ilmenau Seite 69 / 98 Uniformes Sondieren 20 erfolglose Suche erfolgreiche Suche TU Ilmenau Seite 70 / 98

36 Löschen bei geschlossenem Hashing TU Ilmenau Seite 71 / 98 Löschen bei geschlossenem Hashing Problem Wird ein Eintrag gelöscht, kann lookup unter Umständen das falsche Ergebnis liefern. h(x) = (num(c 3 ) + 4) mod 13 und es wird lineares Sondieren verwendet. 0: November (12) 1: 2: Juli (2) 3: Dezember (3) 4: Januar (4) 5: Februar (5) 6: Juni (4) 7: September (6) 8: Maerz (8) 9: April (8) 10: August (10) 11: Oktober (10) 12: Mai (12) Februar wird gelöscht Juni wird gesucht Nicht Gefunden! TU Ilmenau Seite 72 / 98

37 Löschen bei geschlossenem Hashing Idee Eine Zelle darf beim Löschen nicht einfach geleert werden. Sie muss sich merken, dass früher mal ein Wert in ihr stand. Eine solche Zelle kann dann bei der Suche wie eine besetzte Zelle mit dem falschen Schlüssel behandelt werden. Ansatz Eine Zelle hat einen von drei möglichen Zuständen: voll, leer und gelöscht. Löschen: Die Zelle wird auf gelöscht gesetzt. Suchen: Immer bis zur ersten leeren Zelle gehen. Einfügen: gelöschte Zellen können überschrieben werden. TU Ilmenau Seite 73 / 98 Löschen bei geschlossenem Hashing Ein Überlauf tritt spätestens ein, wenn die letzte leere Zelle beschrieben wird. Sinnvoler ist es, den Überlauf schon eintreten zu lassen, wenn die Anzahl von vollen und gelöschten Zellen zusammen eine vorgegebene Schranke überschreitet. Dies ist der Tatsache geschuldet, dass gelöschte Zellen bei der Suche wie volle Zellen behandelt werden. Sinnvole Schranken sind m 1 oder α 0 m mit einem zum Sondierungsverfahren passendem α 0. TU Ilmenau Seite 74 / 98

38 Die Operationen bei geschlossenem Hashing empty(m) Lege ein leeres Array H[0... m 1] an; Initialisiere alle Zellen H[j] mit (, leer) inuse = 0; load = 0; // Zählt volle und gelöschte Zellen // Zählt volle Zellen Initialisiere bound als Überlaufgrenze; TU Ilmenau Seite 75 / 98 Die Operationen bei geschlossenem Hashing lookup(x) i = 0; j = h(x, i); while H[j].status == gelöscht or (H[j].status == voll and H[j].key! = x) do i = i + 1; j = h(x, i); end if H[j].status == leer then return ; else return H[j].data; TU Ilmenau Seite 76 / 98

39 Die Operationen bei geschlossenem Hashing delete(x) i = 0; j = h(x, i); while H[j].status == gelöscht or (H[j].status == voll and H[j].key! = x) do i = i + 1; j = h(x, i); end if H[j].status == voll then H[j].status = gelöscht; load = load 1; end TU Ilmenau Seite 77 / 98 Die Operationen bei geschlossenem Hashing insert(x, r) i = 0; j = h(x,i); l = m; while H[j].status == gelöscht or (H[j].status == voll and H[j].key! = x) do i = i + 1; end j = h(x,i); if H[j] == gelöscht then l = min(l, j); if H[j].status == voll then H[j].value = r; // Erstes gelöschtes merken // Update else if l < m then H[l] = (x,r, voll), load + + ; // gelöschte Zelle gefunden else if H[j].status == leer then if inuse > bound then Überlaufbehandlung; H[j] = (x, r,voll), inuse + +, load + +; // Einfügen TU Ilmenau Seite 78 / 98

40 Überlaufbehandlung bei geschlossenenm Hashing Sinnvoller Ansatz Ein Überlauf tritt ein, wenn die Anzahl der vollen und gelöschten Zellen zusammen (in inuse) eine Schranke α 0 m (in bound) überschreitet. Dabei wird α 0 passend zum Sondierungsverfahren festgelegt. Die Anzahl der vollen Zellen wird in load gespeichert. Falls load + 1 > α 1 m für (z.b.) α 1 = 0.8α 0, verdopple die Tabellengröße, und trage die Schlüssel neu in die größere Tabelle ein. Sonst: Trage alle Schlüssel neu in die alte Tabelle H ein, eliminiere dabei alle gelöscht-markierungen, wie im Folgenden beschrieben. TU Ilmenau Seite 79 / 98 Überlaufbehandlung bei geschlossenenm Hashing Wir organisieren die Tabelle um, ohne zusätzlichen Platz zu benötigen. 1. Schritt: Für i = 0, 1,..., m 1 tue folgendes: Wenn H[i].status = voll, setze H[i].status = alt. Wenn H[i].status = gelöscht, setze H[i].status = leer. 2. Schritt: Für i = 0, 1,..., m 1 tue folgendes: wenn H[i].status = alt dann (x, r) = (H[i].key,H[i],value); H[i].status = leer; Ende insert (x, r); // siehe unten TU Ilmenau Seite 80 / 98

41 Überlaufbehandlung bei geschlossenenm Hashing insert (x, r) erzeugt unter Umständen eine Kettenreaktion. Im Wesentlichen arbeitet insert wie das reguläre insert. Mit alt markierte Zellen werden dabei wie leere Zellen behandelt, d.h. der in ihr stehende Wert (x, r ) wird durch den neuen Eintrag (x, r, voll) verdrängt. Direkt anschließend wird insert (x, r ) ausgeführt. Dies setzt sich fort, bis eine leere Zelle erreicht wird. TU Ilmenau Seite 81 / 98 Universelles Hashing TU Ilmenau Seite 82 / 98

42 Universelles Hashing Universelles Hashing zeichnet sich durch die folgenden Eigenschaften aus: Bei der Festlegung der Hashfunktion h wird (kontrolliert) Zufall eingesetzt. Es werden Randomisierte Algorithmen verwendet. Die Analyse beruht nur auf Zufallseigenschaften von h und nicht auf Annahmen über die Schlüsselmenge S. TU Ilmenau Seite 83 / 98 Die Uniformität von Linearen Gleichungen Satz Sei U [s] r und m s eine Primzahl. a 1,..., a r seien aus [m] zufällig gewählt. Ferner sei h: U [m] gegeben durch ( r ) h(c 1...c r ) = a i c i Dann gilt für x, z U mit x z: d.h. (UF 2 ) ist erfüllt. i=1 P (h(x) = h(z)) = 1 m, mod m. TU Ilmenau Seite 84 / 98

43 Die Uniformität von Linearen Gleichungen Beweis Im Folgenden rechnen wir stets im Körper [m] = Z m = Z/mZ, d.h. modulo m. Sei x = (c 1,...,c r ) und z = (d 1,... d r ) und u = x z = (c 1 d 1,...,c r d r ). Für die Wahl von a = (a 1,..., a r ) gibt es insgesamt m r Möglichkeiten. Wieviele von diesen Möglichkeiten führen zu < a, x > mod m := r a i c i mod m =< a, z > mod m? i=1... TU Ilmenau Seite 85 / 98 Die Uniformität von Linearen Gleichungen Beweis (Fortsetzung) Diese Gleichheit ist äquivalent zu Die Menge < a, x z > mod m =< a, u > mod m = 0. W u = {(a 1,..., a r ) [m] r < a, u > mod m = 0} ist ein (r 1)-dimensionaler Untervektorraum von [m] r und enthält somit m r 1 Elemente. Damit ist der Anteil der Koeffizientenmöglichkeiten, die x und z auf denselben Hashwert abbilden gerade m r 1 m r = 1 m. TU Ilmenau Seite 86 / 98

44 Ein anderes Szenario U [p] r mit p prim (auch r = 1!) und die Tabellengröße m p ist beliebig. Wähle a 1,...,a r aus [p] zufällig. Sei h(c 1... c r ) = (( r ) a i c i mod p ) mod m. i=1 Satz Für alle Paar x, y U, x y gilt P(h(x) = h(z)) 2 m. TU Ilmenau Seite 87 / 98 (UF 2 ) und multiplikatives Hashing Satz Wenn man beim multiplikativen Hashing h(x) = (a x mod 2 k )div 2 k l mit U = [2 k ] und m = 2 l, den Koeffizienten a als zufällige ungerade Zahl in [2 k ] wählt, dann gilt für beliebige x, z U mit x z: P(h(x) = h(z)) 2 2 l = 2 m. Fazit Durch geeignete Parameter-Wahl können wir annähernd (UF 2 ) realisieren. TU Ilmenau Seite 88 / 98

45 Tabellenhashing Sei U = [s] r und m = 2 l mit l w wobei die Wortlänge w frei gewählt ist. [m] entspricht damit {0, 1} l. Die Hashfunktion h wird durch ein zweidimensionales Array A[1...][0...s 1] mit Einträgen aus {0, 1} w repräsentiert. Sie berechnet sich gemäß h(c 1...c r ) = (A[1][c 1 ] A[r][c r ]) div 2 w l wobei das bitweise XOR der Wörter ist. D.h. h(c 1... c r ) besteht aus den ersten l Bits des XOR-Termes. TU Ilmenau Seite 89 / 98 Tabellenhashing Ein Beispiel Σ = {0, 1} 3 (Schlüssel sind Zahlen in Oktalnotation), w = 4, r = 6, l = 3. A: Buchstaben i = h((011, 101, 011, 111, 100, 011)) = (die ersten 3 Bits von ) = (die ersten 3 Bits von 0010) = 001. TU Ilmenau Seite 90 / 98

46 Tabellenhashing Nachteil des Tabellenhashings Das Array A[1...r, ][0...s 1] benötigt Platz r s (Wörter). Beispiel r = 20 ASCII-Zeichen pro Wort, Σ = {0, 1} 8, w = 32. A[1...r][0...s 1] benötigt rs(w/8) = = Bytes, d.h. knapp 20 kb. Sinnvoll nur für große Hashtabellen. Platzsparende Varainte, aber etwas langsamer: Σ = {0, 1} 4, Tetraden. Platz im Beispiel: rs(w/8) = = 2560 Bytes. TU Ilmenau Seite 91 / 98 Tabellenhashing Vorteile des Tabellenhashings Extrem schnelle Auswertung ( ebenso schnell wie +) Dasselbe A kann für m = 2 4, 2 5, 2 6,..., 2 w benutzt werden. Ideal für die Kombination mit der Verdoppelungsstrategie: Verdopple Tabellengröße = erhöhe l um 1; Einträge in A bleiben unverändert Beweisbar gutes Verhalten, wenn die Einträge von A zufällig sind Proposition Wenn die Einträge in A[1... r][0... s 1] zufällig gewählt werden, dann gilt für x, z U mit x z: Beweis: Übung. P(h(x) = h(z)) = 1 m. TU Ilmenau Seite 92 / 98

47 Universelles Hashing Leichte Modifikation von vorherigen Beweisen liefert: Proposition Wenn P(h(x) = h(z)) c m, für beliebige x, z U, x z, und wenn wir Hashing mit verketteten Listen benutzen, dann ist die erwartete Zahl von Schlüsselvergleichen höchstens c α bei der erfolglosen Suche höchstens c α (Mittelung über x 1,...,x n ) bei der erfolgreichen Suche. Wenn α α 1 sichergestellt ist, α 1 konstant ( Verdoppelungsstrategie) ist die erwartete Suchzeit O(1). TU Ilmenau Seite 93 / 98 Universelles Hashing Definition (c-universelle Klasse von Hashfunktionen) Eine Menge H von Hashfunktionen, d.h. H {h h: U [m]}, heißt c-universelle Klasse von Hashfunktionen, wenn für beliebige x, z U mit x z gilt: {h H h(x) = h(z)} c H m. In anderen Worten:... wenn für für beliebige x, z U mit x z und für zufällig gewähltes h aus H gilt: P(h(x) = h(z)) c m. TU Ilmenau Seite 94 / 98

48 Universelles Hashing Beispiele U [p], p Primzahl, Tabellengröße m p beliebig. h(x) = ((a x) mod m für a {1,...p 1}. Dann ist H p,m = {h a 1 a < p} eine 2-universelle Klasse. U = ASCII r = {0,...,255} r, m > 256 Primzahl. ( r ) h a1,...,a r (c 1...c r ) = a i c i mod m, für c 1... c r U. i=1 Dann ist H m,r = {h a1,...,a r a 1,...,a r [m]} eine 1-universelle Klasse. TU Ilmenau Seite 95 / 98 Universelles Hashing Beispiele Multiplikatives Hashing mit zufälligem Faktor führt zu einer 2-universellen Klasse. Tabellenhashing führt zu einer 1-universellen Klasse. TU Ilmenau Seite 96 / 98

49 Universelles Hashing Die obige Proposition liest sich nun so: Wenn H c-universell ist und man (in empty(m)) ein h aus H zufällig wählt, dann gelten die oberen Schranken c α bzw c α für die Anzahl der Schlüsselvergleiche bei erfolgloser bzw. erfolgreicher Suche. TU Ilmenau Seite 97 / 98