4. Hashverfahren. geg.: Wertebereich D, Schlüsselmenge S = {s 1,..., s n } D. Menge A von Speicheradressen; oft: A = {0,..., m 1}

Transkript

1 Hashverfahren geg.: Wertebereich D, Schlüsselmenge S = {s 1,..., s n } D Menge A von Speicheradressen; oft: A = {0,..., m 1} jedes Speicherverfahren realisiert h : D A mögliche Implementierungen von h durch Liste, Baum,... alternativ: Hashing berechne h(s) direkt (meist in O(1)) aus s Problem: D meist sehr groß daher: h i.allg. nicht injektiv; oft: h(s) = s mod m Kollision bei Einfügen von s, wenn s S, s s h(s) = h(s )

2 106 Kollisionsbehandlung 1.) offene Hashverfahren: verwende anderen, freien Platz h (s) A (innerhalb der Hashtabelle) 2.) Hashverfahren mit Verkettung: h(s) führt zu Liste mit Elementen s, für die h(s ) = h(s)

3 Wahl der Hashfunktion Anforderung: wenige Kollisionen Divisionsrest-Methode in Praxis meist am besten h(s) = s mod m ungünstiges m: 2er-Potenz, 10er-Potenz,... Beispiel: Preise und m = 100: h({49, 69, 99, 149, 199, 299, 399}) = {49, 69, 99} gut: m Primzahl

4 108 Multiplikative Methode multipliziere mit irrationaler Zahl θ und ignoriere ganzzahligen Anteil h(s) = m (s θ s θ ) effizient implementierbar bei m = 2 k durch int, 2 Shifts gut: θ = (goldener Schnitt - 1)

5 Hashverfahren mit Verkettung Synonyme werden in dyn. Datenstruktur (z.b. Liste) außerhalb der Hashtabelle gespeichert Separate Verkettung jeder Hashtabelleneintrag ist Anfang einer Liste von Synonymen Beispiel: (mit h(s) = s mod 7, S = {1, 10, 3, 6, 20, 13})

6 110 Operationen in Hashtabelle Suchen: beginne mit h(s) und folge Verweisen bis gefunden oder Listenende Einfügen: füge s am Ende der Liste h(s) ein, wenn s nicht gefunden (!) Löschen: suche s und entferne s aus Liste

7 Direkte Verkettung jeder Hashtabelleneintrag ist Zeiger auf Liste von Synonymen Vorteil: weniger Ausnahmebehandlungen/ Abfragen als bei separater Verkettung Beispiel: Suche, Einfügen und Löschen analog zu separater Verkettung

8 112 Direkte Verkettung in Java public class HashTable<D> implements MyCollection<Integer,D>{ protected int size; protected List<Integer,D>[] tab; public HashTable(int n) {size = n; for (int i=0; i<tab.length; i++) tab = new List[size]; tab[i] = new List<Integer,D>();} private int h(int key) {return key % size;} public D find(integer key) throws Exception { List<Integer,D> list = tab[h(key)]; return list.find(key);} public void insert(integer key, D content) { List<Integer,D> list = tab[h(key)]; list.insert(key,content);} // Mehrfacheintraege erlaubt public void delete(integer key) { List<Integer,D> list = tab[h(key)]; list.delete(key);} } public HashIterator iterator() {return new HashIterator();}

9 113 Analyse von direkter Verkettung im schlechtesten Fall: alle Schlüssel in gleicher Liste t suche (n) O(n) im Mittel: Annahme: alle Hashadressen gleich wahrscheinlich def.: Belegungsfaktor α := n m durchschnittliche Länge l einer Liste: l = α bei erfolgloser Suche: bei erfolgreicher Suche: W t suche A (n) = α O(1) für n m n ˆt suche A (n) = 1 n (1 + j 1 m ) = 1 + n 1 2m 1 + α 2 j=1 Aufwand des Löschens: wie bei erfolgreicher Suche Einfügen: 1 (bzw. wie bei erfolgloser Suche, wenn keine Duplikate)

10 114 Vergleich: separate vs. direkte Verkettung α separate Verkettung direkte Verkettung erfolgreich erfolglos erfolgreich erfolglos Anzahl bei der Suche betrachteter Einträge (nach Ottmann, Widmayer) Bemerkung: die Synonymlisten können (aufgeteilt in Seiten) im Sekundärspeicher liegen α > 1 möglich

11 Offene Hashverfahren Synonyme innerhalb der Hashtabelle gespeichert betrachte Folge von Hashfunktionen h i : D A i = 0, 1, 2,... Einfügen: sind h 0 (s),..., h i 1 (s) belegt und h i (s) frei, so speichere s in h i (s) Suche: suche s in h 0 (s),..., h i (s) bis h i (s) enthält s oder bis h i (s) frei

12 116 Löschen s zunächst suchen Problem: naives Entfernen zerstört Suchketten für andere Elemente Lösungsmöglichkeit: s nur als gelöscht markieren aber nicht wirklich entfernen markierte Plätze beim Einfügen wiederverwenden Effizienz leidet unter Löschmarkierungen offenes Hashing nur geeignet, wenn Löschen selten

13 Lineares Sondieren offenes Hashverfahren mit h i+1 (s) = h i (s) + 1 mod m für i IN Beispiel: füge ein 6, 10, 13, 20, 3, 1 Vorteil: einfach implementierbar Nachteil: primäre Häufung verschlechtert Effizienz

14 118 Aufwand ( Knuth) im schlechtesten Fall: linear (O(n)) im Mittel: Annahme: alle Hashadressen gleich wahrscheinlich falls Tabelle beim Einfügen bereits k Einträge enthält: p 1 = m k m Wahrscheinlichkkeit, daß beim 1. Versuch freier Platz gefunden p 2 = k m m k m 1... beim 2. Versuch... p 3 = k m k 1 m 1 m k m 2... beim 3. Versuch... allgemein: p i = ( i 2 j=0 Erwartungswert beim (k + 1)-ten Einfügen: E k+1 = k j m j ) m k m i+1... beim i. Versuch... k+1 i=1 i p i = }{{} (Induktion, Mehlhorn) m + 1 m k + 1

15 119 E = 1 k k = m+1 k E j j=1 k j=1 Mittlerer Einfügeaufwand bei k Schlüsseln 1 m j+2 = m+1 k (H m+1 H m k+1 ) wobei: H i = i m+1 k (ln(m + 1) ln(m k + 1)) = m+1 k ln( m+1 m k+1 ) = 1 k m+1 ln( 1 1 m+1 k = 1 α (ln(1) ln(1 α }{{} )) =0 ) j=1 1 j 1 k m ln(i) }{{} Eulersche Konstante harmonische Zahlen = 1 α ln(1 α ) wobei α = k m+1

16 120 Bemerkungen bei linearem Sondieren ist Gleichverteilungsannahme unrealistisch daher in Praxis: E = 1 α 2 1 α α E E (nach Wirth) Folgerung: Tabelle in Praxis 10% zu groß wählen

17 Quadratisches Sondieren h i (s) = (h 0 (s) + i 2 ) mod m für i > 0, m prim ggf. Einfügen unmöglich, obwohl noch Plätze frei besser als lineares Sondieren, da keine primäre Häufung

18 Perfektes Hashing Idee: analog zu optimalen Suchbaum Hashverfahren für feste Schlüsselmenge S = {s 1,..., s n } {1,..., N} optimieren gesucht: perfekte (d.h. injektive) Hashfunktion, die effizient berechenbar (in O(1)) und mit möglichst kleiner Hashtabelle erreichbar: (Details s. Mehlhorn) Auswertung in O(1) Tabellengröße m < 3n also: α > 1/3 Ermittlung einer geeigneten Hashfunktion in O(n N) (bei großem N verbesserbar zu: O(n 3 log n + log(log N)))

19 123 Ermittlung einer geeigneten Hashfunktion 1) bestimme k (1 k < N) mit n 1 i=0 S i 2 < 3n wobei S i := {x S (kx mod N) mod n = i} für i = 0,..., n 1 Aufwand: O(n N) (geeignetes k existiert! Mehlhorn) 2) c i := S i ( S i 1) + 1 für i = 0,..., n 1 m := n 1 i=0 c i = n + n 1 i=0 < n + 3n n = 3n S i 2 n 1 i=0 S i

20 124 3) bestimme k i (i = 0,..., n 1, 1 k i < N) mit h i (x) := (k i x mod N) mod c i auf S i injektiv Aufwand für i: O( S i N) (geeignetes k i existiert! Mehlhorn) 4) h(x) := let i = (k x mod N) mod n, j = (k i x mod N) mod c i in i 1 + j l=0 c l }{{} vorberechnet Auswertung: O(1) (2 *, 4 mod, 1 + )

21 125 Beispiel: Perfektes Hashing S = {1, 3, 4, 7}, N = 7, n = 4 1) probiere k = 1: S 0 = {4, 7}, S 1 = {1}, S 2 =, S 3 = {3} 3 S 1 2 = = 6 < 12 = 3n k = 1 geeignet i=0 2) c 0 := 3, c 1 := 1, c 2 := 1, c 3 := 1, m := 6 3) probiere k 0 = 1: h 0 (x) := (x mod 7) mod 3 h 0 (4) = 1, h 0 (7) = 0 k 0 = 1 geeignet für i = 1,..., 3: k i = 1 trivialerweise geeignet, wegen S i 1 4) Hashtabelle: {z } S 0 {z} S 1 {z} S 2 {z} S 3

22 Universelles Hashing Details s. Mehlhorn statt Hashfunktion h manuell vorgeben: h zufällig aus Topf H ziehen Vorteil: bei mehrfachem Aufbau einer Hashtabelle für (fast) festes S wird die Effizienz über H gemittelt (z.b. für Symboltabelle eines Compilers) ein dauerhaft unglücklich gewähltes h wird vermieden z.b. H := {h a,b h a,b (x) := (ax + b mod p) mod m, a, b {0,..., N 1}} wobei m, N IN, p prim

23 Dynamisches Hashing erweiterbare bzw. verkleinerbare Hashtabelle insbesondere für Sekundärspeicher Varianten: Lineares Hashing Erweiterbares Hashing Gridfile (Details: Ottmann, Widmayer)

24 128 Lineares Hashing Folge von Hashfunktionen h i (x) = x mod (m 0 2 i ) i = 0, 1,... stets zwei Funktionen, h i und h i+1, aktiv j + m h i+1 j: 87,167,247 j: 167 h i m *2i : m0 *2 i : 0 h i+1 h i+1 0 * i : j + m *2 i : 0... frei Erweitern 87, hi+1 h i frei

25 129 Erweitern und Verkleinern beim Linearen Hashing Erweitern falls α > α max : j := j + 1; Schlüssel in Bucket B j 1 werden gemäß h i+1 umgespeichert falls hiernach j = m 0 2 i : Tabellengröße verdoppeln; j := 0; i := i + 1 Verkleinerung umgekehrt, wenn α < α min

26 130 Zusammenfassung: Hashverfahren im Mittel sehr effizient (bei α < 90%) (meist: O(1)) im Worst Case: schlecht (O(n)) #Schlüssel muss ungefähr bekannt sein, sonst Platzverschwendung bzw. Ineffizienz (Abhilfe: dynamische Hashverfahren) keine sortierte Ausgabe möglich ( Variante: monotone Hashfunktion) Löschen bei offenem Hashing umständlich auch mehrdimensionales Hashing möglich ( partial match queries)