Algorithmen und Datenstrukturen 7. Vorlesung

Transkript

1 Algorithmen und Datenstrukturen 7. Vorlesung Martin Dietzfelbinger 23. Mai 2005 v h h v, v,2 2 bal(v) = h 2 h {, 0, }. Definition Ein höhenbalancierter binärer Suchbaum heißt AVL-Baum. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Effekt: AVL delete Lösche wie bei gewöhnlichem BSB: Fälle, DeleteMin Zentraler Effekt: Ein Knoten u wird entfernt, dem mindestens ein Unterbaum fehlt. Wenn Balancebedingung nicht verletzt: fertig. Wenn Balancebedingung verletzt, laufe den Weg von u zur Wurzel, teste an jedem Knoten die Balancebedingung, führe gegebenenfalls eine Einfach- oder Doppelrotation aus. Achtung: Möglicherweise auf mehreren Levels nacheinander Rotation nötig. Beispiel: Fibonacci-Bäume iefe 5 2 Knoten iefe 6 20 Knoten Entfernen des höchsten Blattes in einem minimal großen AVL- Baum löst Rotationskaskade aus. Hier wurde ein Fehler korrigiert FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

2 AVL delete Eingabe: : AVL tree, x: key Ausgabe: : AVL tree, shallower: boolean. Fall: = NIL ( Erfolglose Suche, Schlüssel x nicht da! ) Keine Rebalancierung nötig! return (, false) 2. Fall:.key = x und (.left = NIL oder.right = NIL) Entferne Wurzelknoten! x war und ist AVL- Baum Falls.left = NIL:.right Falls.right = NIL:.left return (, true) FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Fall 2:.key = x beide Unterbäume nicht leer x y kleiner (.right,y,s,right_shallower) AVL_deletemin(.right).data s;.key y; Rebalancierung_rechts; Fall 3:.key > x (.left,left_shallower) <- AVL_delete(.left,x) Rebalancierung_links; Fall 4:.key < x (.right,right_shallower) <- AVL_delete(.right,x) Rebalancierung_rechts; FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

3 In AVL deletemin: Fall A:.left = NIL Wurzel entfernen In AVL deletemin: Fall B:.left <> NIL: bleibt AVL-Baum y.key; s.data;.right; return (,y,s,true) (.left,y,s,left_shallower) AVL_deletemin(.left); Rebalancierung_links; ( gibt shallower einen Wert ) return (,y,s,shallower) FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Rebalancierung links: (Rebalancierung rechts geht symmetrisch) : : Fall Aktion.Fall: left_shallower = false shallower <- false; 2 umgebaut zu 2 Rückgabewerte: Neuer Baum und Boolean shallower 2. Fall: left_shallower = true.bal = - geschrumpft shallower <- true;.bal <- 0; FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

4 Fall 3.Fall: left_shallower = true.bal = 0 Aktion 4.Fall: left_shallower = true.bal = geschrumpft shallower <-false;.bal <- ; 2 Unterfälle je nach Aussehen von 2. 2 ist nicht leer! FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Fall 4.:.right.bal = 0; Fall 4.2:.right.bal = ;.left.right Linksrotation! <- left_rotate();.left.bal <- ;.bal <- -; shallower <- false; Hier wurde ein Fehler korrigiert! Linksrotation! <- left_rotate();.left.bal <- 0;.bal <- 0; shallower <- true; FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

5 Fall 4.3:.right.bal = -; Fall 4.3 (Forts.) Betrachte eilbäume von 2 =.right. : Doppelrotation! <- right_left_rotate(); shallower <- true; Neue Werte: FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD altes.bal.left.bal.right.bal.bal Hier wurde ein Fehler korrigiert! (Spaltenüberschriften vertauscht) Das alte.bal enthält (nach der Doppelrotation) den Balancefaktor, der ursprünglich in der Wurzel des zentralen Unterbaums stand. Proposition Die rekursive Prozedur AVL delete führt die Wörterbuchoperation delete korrekt durch. D.h.: es entsteht wieder ein AVL-Baum. Die Prozedur hat Laufzeit O(log n) und führt an jedem Knoten auf dem Weg von der Wurzel zum gelöschten Knoten höchstens eine Einfach- oder Doppelrotation durch. Satz In AVL-Bäumen kostet jede Wörterbuchoperation Zeit O(log n), wo n die Anzahl der Wörterbucheinträge ist. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

6 Mehrweg-Such-Bäume Mehrweg-Such-Bäume Bäume aus Knoten mit variablem Ausgrad Knoten mit mehreren Unterbäumen: x x l Beispiel eines N-MSB: Wurzel x < < x l. Für y i in i, 0 i l: 0 l- y 0 < x < y < x 2 < < y l < x l < y l l FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Mehrweg-Such-Bäume Definition Mehrweg-Suchbäume (MSBe) über dem (angeordneten) Universum U sind wie folgt induktiv definiert: Mehrweg-Such-Bäume Möglichkeit für Implementierung eines Knotens: Variante : (0) Der leere Baum ist ein U-MSB. () Ist l und sind x < x 2 < < x l Schlüssel in U und sind 0,,..., l U-MSBe mit: keys: lmax Für y i in i, 0 i l: y 0 < x < y < x 2 < < y l < x l < y l dann ist auch ( 0,x,,x 2,...,x l, l,x l, l ) ein U- Mehrweg-Suchbaum. l: sons: 3 l_max: l max FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

7 Mehrweg-Such-Bäume Möglichkeit für Implementierung eines Knotens: Variante 2: keys: sons: 0 3 Mehrweg-Such-Bäume Variante 3: MSB-Knoten wird durch aufsteigend sortierte lineare Liste von Binärbaumknoten dargestellt. Im Knoten muss als boolescher Wert vermerkt sein, ob es sich um den Knoten am Listenende handelt. (Im Bild: *.) Elegant: Für die Suche kann man die gewöhnliche Suchprozedur für binäre Suchbäume benutzen. l: 3 FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Mehrweg-Such-Bäume : * 7 6 * 2 4 * 0 3 * 2 25 * 9 * 2 * 2-3-Bäume Definition Ein Mehrweg-Suchbaum heißt ein 2-3-Baum, wenn gilt: (a) Jeder Knoten enthält oder 2 Schlüssel (also hat jeder Knoten 2 oder 3 Unterbäume, was der Struktur den Namen gibt); (b) Für jeden Knoten v in gilt: wenn v einen leeren Unterbaum hat, so sind alle Unterbäume unter v leer, d.h. v ist dann Blatt; (c) Alle Blätter von haben dieselbe iefe. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

8 2-3-Bäume 2-3-Bäume Beispiele: Beispiele: Leerer 2-3-Baum: I Level Baum mit 2 Ebenen: G O Level G O Level A H L M R S U Level 0 = Blattebene A I L R Level 0 = Blattebene NB: Die Ebenen werden von den Blättern her numeriert. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Bäume L O 2-3-Bäume G A M R U A O Kein 2-3-Baum (zu großer Grad). L M R Kein 2-3-Baum (Blätter in verschiedenen iefen). FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

9 2-3-Bäume G O A I L Kein 2-3-Baum (Leerer Unterbaum in Nicht-Blatt). Proposition 2-3-Bäume: Logarithmische iefe Die iefe eines 2-3-Baums mit n Daten ist mindestens log 3 (n + ) und höchstens log(n + ). [log 3 x 0.63 log 2 x] Level h h- 0 FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Suche in 2-3-Bäumen: Rekursiv lookup(,x), für 2-3-Baum, x U.. Fall: =. Ausgabe: 2. Fall: Die Wurzel von enthält Schlüssel x (und eventuell x 2 > x ). Suche in 2-3-Bäumen: Rekursiv 2a: x < x : Rufe lookup für ersten Unterbaum 0 auf. 2b: x = x : gefunden. 2c: x < x und ( x 2 existiert nicht oder x < x 2 ): Rufe lookup für zweiten Unterbaum auf. 2d: x 2 existiert und x = x 2 : gefunden. 2e: x 2 existiert und x 2 < x: Rufe lookup für dritten Unterbaum 2 auf. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

10 Klar: Suche in 2-3-Bäumen: Rekursiv Zeitaufwand: Wenn x im Knoten v x sitzt: Für jeden Knoten v auf dem Weg von der Wurzel zu v x entstehen Kosten O(). Zeit für Suche ist O(log n). Einfügen in 2-3-Bäumen: Rekursiv insert(,x), für 2-3-Baum, x U. Resultat: Neuer Baum, Boolescher Wert higher, der angibt, ob höher als ist. Invariante (I): (Benutzen Kontrollieren): höher als hat in der Wurzel nur einen Schlüssel.. Fall: =. Erzeuge neuen 2-3-Baum-Knoten mit Eintrag x, 2 leeren Unterbäumen (Blatt!) return (t, true) (I) stimmt. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Einfügen in 2-3-Bäumen: Rekursiv 2. Fall: Wurzel von enthält Schlüssel x und eventuell x 2 > x, entsprechend Unterbäume 0, und eventuell 2. 2a: x < x : insert( 0 ) liefert 0 und sub higher. Rebalancierung (s.u.). 2d: x 2 existiert und x = x 2 : Update. higher false; 2e: x 2 existiert und x 2 < x: insert( 2 ) liefert 2 und sub higher. Rebalancierung (s.u.). 2b: x = x : Update. higher false; 2c: x < x und ( x 2 existiert nicht oder x < x 2 ): insert( ) liefert und sub higher. Rebalancierung (s.u.). FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

11 Einfügen in 2-3-Bäumen: Rebalancierung Fälle 2a/2c/2e: Fall 2a(i)/2c(i)/2e(i): sub_higher = false. Der veränderte eilbaum ist nicht tiefer geworden. Keine weitere Rebalancierung nötig: Setze higher false. Einfügen in 2-3-Bäumen: Rebalancierung Fall 2a(ii)/2c(ii): x 2 existiert nicht und sub_higher = true 2a(ii): Benutze (I)! x neu, tiefer 0 z alt Umbau z x higher false FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Einfügen in 2-3-Bäumen: Rebalancierung Einfügen in 2-3-Bäumen: Rebalancierung 2c(ii): Benutze (I)! Fall 2a(iii)/2c(iii)/2e(iii): alt 0 x z neu, tiefer Umbau 0 x 0 z x 2 existiert nicht und sub_higher = true Benutze jeweils (I)! 0 higher false FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

12 2a(iii): Einfügen in 2-3-Bäumen: Rebalancierung 2c(iii): Einfügen in 2-3-Bäumen: Rebalancierung x x 2 x x x 2 z 0 z Umbau z x 2 z Umbau x x 2 neu, tiefer higher true Prüfe: (I) erfüllt. higher true Prüfe: (I) erfüllt. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Einfügen in 2-3-Bäumen: Rebalancierung Einfügen in 2-3-Bäumen 2e(iii): x x 2 x 2 Beobachtung: 2-3-Bäume wachsen in der iefe durch Spalten der Wurzel. Proposition 0 2 z Umbau x z (a) Die Prozedur insert ist korrekt, d.h. sie erhält die 2-3-Baum- Struktur. higher true Prüfe: (I) erfüllt (b) Das Einfügen eines Schlüssels in einen 2-3-Baum mit n Schlüsseln benötigt Zeit O(log n) und die Erzeugung von höchstens log 2 n neuer Knoten. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

13 Beweis: Einfügen in 2-3-Bäumen (a) Man kontrolliert in jedem Fall des Algorithmus nach, dass die 2-3-Baum-Struktur wiederhergestellt wird. (b) Für die Bearbeitung eines Levels in der insert-prozedur wird Zeit O() benötigt. Auf jedem der log n Levels wird höchstens Knoten neu gebildet. Löschen in 2-3-Bäumen Prinzip: Suche den kleinsten Schlüssel y x, der in einem Blatt gespeichert ist. (x oder der Inorder-Nachfolger von x.) Setze y an die Stelle von x und entferne y. Fazit: Man muss sich nur um das Löschen eines Eintrags y in einem Blatt kümmern. Folgerung: Für jedes n 0 existiert ein 2-3-Baum mit n Schlüsseln. (Man füge in einen anfangs leeren Baum die Schlüssel,...,n ein.) FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Löschen in 2-3-Bäumen Einfacher Fall: Neben y hat das Blatt noch andere Einträge. Keine Umstrukturierung nötig. Rebalancierungsfall: Durch das Streichen von y wird das Blatt leer, verliert also an Höhe. Ähnlich wie bei den Einfügungen werden flacher gewordene eilbäume durch lokale Umstellungen wieder auf die Höhe der anderen eilbäume gebracht. oder Hashing Schlüsseltransformationsverfahren Wiederholend lesen: Folien aus GdP zu B-Bäumen. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

14 Gegeben: Universum U (auch ohne Ordnung) und Wertebereich R. Ziel: Implementiere Wörterbuch oder dynamische (partielle) Abbildung f : S R, wo S U endlich Werden sehen: Erreichbar ist Zeit O() pro Operation im Durchschnitt Unabhängig vom Umfang der Datenstruktur! Gegensatz Bäume: O(log(n)) S U h 0 2 m h: U [m] U : Universum der Schlüssel [m] = {0,...,m } : Indexbereich für abelle S U, S = n FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Grundansatz: Speicherung in m Plätzen einer abelle [0..m ]. Aus Schlüssel x U wird ein Index h(x) {0,...,m } berechnet. x wird in h(x) umgewandelt/transformiert. Idealvorstellung: Speichere x in Zelle [i], wo i = h(x). Beispiel: U = {A,...,Z,a,...,z} 3 Nichtleere Wörter mit mindestens 3 Buchstaben: unendlich! h : U {0,...,2} wird definiert durch h(c c 2 c r ) = num(c 3 ) mod 3, wo num(a) = num(a) = 0 num(b) = num(b) =... num(z) = num(z) = 25 FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

15 h(c...c r ) = num(c 3 ) mod 3 x num(c 3 ) h(x) Januar 3 0 Februar Maerz 4 4 April 7 4 Mai 8 8 Juni 3 0 Juli August 6 6 September 5 2 Oktober 9 6 November 2 8 Dezember 25 2 Definition Eine Funktion h: U [m] heißt eine Hashfunktion. Wenn S U gegeben ist (oder ein f : S R), verteilt h die Schlüssel in S auf [m] = {0,...,m }. Idealfall: Die Einschränkung h S ist injektiv, d. h. für jedes i [m] existiert höchstens ein x S mit h(x) = i. Beispiel: Auf S = {Februar, Maerz, Mai, Juni, Juli, Dezember} ist obiges h injektiv, nicht aber auf S = {Februar,Maerz,April} FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Sprechweise: h perfekt für S : h S injektiv. Falls h perfekt für S: Speichere x bzw. (x,r) in abellenplatz [h(x)]. lookup(x): Berechne i = h(x). (Dies sollte effizient möglich sein.) Prüfe, ob in [i] Schlüssel x steht. Falls ja: (x,r) ausgeben, sonst x / S. Kollision: x,y S, x y, h(x) = h(y) Leider sind Kollisionen praktisch unvermeidlich (Ausweg: speziell auf S abgestimmte Hashfunktion h.) Fall: h rein zufällig, S = n, S = {x,...,x n }. D. h.: Uniformitätsannahme (UF ): Werte h(x ),...,h(x n ) in {0,...,m } n sind rein zufällig, d.h. jeder der m n möglichen Wertevektoren (i,...,i n ) {0,...,m } n kommt mit derselben Wahrscheinlichkeit /m n vor. ritt ein, wenn S U rein zufällige Menge ist und h das Universum in gleich große eile schneidet, d. h. h ({i}) = U m oder = U m, i = 0,...,m. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

16 Mit (UF ): Prob(h ist injektiv auf {x,...,x n }) = m m m m m 2 m m n + m (Für i =,...,n ist die Wahrscheinlichkeit, dass h(x i ) in [m] {h(x ),...,h(x i )} liegt, genau m i+ m.)... = ( ) ( 2 ) m m e 0 e m e m 2 e n m (denn für x 0 ist + x < e x ), also... ( n m = e n(n ) 2m. ) Prob(h injektiv auf S) e n(n ) 2m. Wunsch: Linearer Platzverbrauch, also Auslastungsfaktor α = n m nicht kleiner als eine Konstante α 0. Dann: Prob(h injektiv auf S) e α 0 (n ) 2. Winzig für nicht ganz kleine n! Fazit: Kollisionen kommen vor. Kollisionsbehandlung FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Beispiel: Hashing mit verketteten Listen : 0: : 2: 3: 4: 5: 6: 7: Juni Februar September Maerz August 8: 9: 0: : 2: November Juli Dezember Januar April Oktober Mai Hashing mit verketteten Listen engl.: chained hashing Benutze Array [0..m ] von Zeigern auf Anfänge von m einfach verketteten linearen Listen L 0,...,L m. Liste L i enthält die Schlüssel aus Behälter ( bucket ) B i = {x S h(x) = i}, u.u. mit Zusatzinformation, d. h. dem Wert r = f(x). FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

17 Algorithmen(skizzen) empty(m): Erzeugt Array [0..m-] mit m NIL-Zeigern und legt h: U [m] fest. Kosten: Θ(m). Beachte: Man wählt h, ohne S zu kennen! insert(x, r): Berechne i = h(x); suche Schlüssel x in Liste bei [i]; falls gefunden: ersetze Daten bei x durch r; sonst: füge (x,r) in Liste [i] ein. Kosten: O( + Zahl der Schlüsselvergleiche x = x? )... falls die Auswertung von h(x) und ein Schlüsselvergleich Zeit O() kostet.. Fall: x nicht vorhanden erfolglose Suche Zahl der Schlüsselvergleiche = B i. 2. Fall: x ist vorhanden erfolgreiche Suche Mittlere Zahl der Schlüsselvergleiche = 2 B i. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD delete(x): Berechne i = h(x); suche Schlüssel x in Liste bei [i]; falls gefunden: lösche Eintrag; sonst: tue nichts. Kosten: wie bei insert. Ziel: Analysiere erwartete Kosten. Genügt: Analysiere erwartete Anzahl der Schlüsselvergleiche. Szenario: n Schlüssel x,...,x n in Struktur gespeichert, Menge S. Nun: Suche nach y U. α = n m : der (aktuelle) Auslastungsfaktor. Fall : y / S erfolglose Suche. Wieviele Schlüsselvergleiche im erwarteten Fall? Abgeschwächte Uniformitätsannahme (UF 2 ): Für je 2 Schlüssel x z in U gilt: Prob(h(x) = h(z)) m FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

18 Definiere Zufallsgrößen/Zufallsvariable, für x,z U: { falls h(x) = h(z), Y x,z := 0 falls h(x) h(z). Nach (UF 2 ): E(Y x,z ) = Prob(h(x) = h(z)) m. Anzahl der Schlüsselvergleiche/Listenlänge: aktuelle Länge der bei der b y = {x S h(y) = h(x)} = Suche zu durchlaufenden = Y x,y. x S Liste Erwartete Listenlänge: Proposition E(b y ) = x S E(Y x,y ) x S m = n m = α. Die erwartete Anzahl von Schlüsselvergleichen bei erfolgloser Suche unter der Annahme (UF 2 ) ist höchstens α. Der erwartete Zeitbedarf für eine erfolglose Suche ist O(+α). Fazit: Wenn α α, α konstant (z.b. = 2), dann ist die erwartete Zeit für eine erfolglose Suche O(). FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Fall 2: y S erfolgreiche Suche. Wieviele Schlüsselvergleiche im erwarteten Fall? (nach (UF 2 )) Gemittelt über alle Fälle y = x, x S (jeweils W. n )! Wir nehmen an: Einfügereihenfolge ist x,...,x n, Elemente werden beim Einfügen ans Listenende gesetzt. Im Fall y = x i wird y mit genau j i Y xj,y Gemittelt über alle i: n i n Y xj,x i = + n j i j<i n Erwartungswert (mit (UF 2 )) ist höchstens + n j<i n Y xj,x i. m = + (n )n n 2m < + α 2. Listenelementen verglichen. (Vor oder gleich y in der gleichen Liste!) FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

19 Proposition Die erwartete (mit (UF 2 )) mittlere (über die Einträge x,...,x n gemittelte) Anzahl von Schlüsselvergleichen bei erfolgreicher Suche ist höchstens + α 2. Der erwartete Zeitbedarf für eine erfolgreiche Suche ist O( + α). Fazit: Wenn α α, α konstant (z.b. = 2), dann ist die erwartete Zeit für eine erfolgreiche Suche O(). Kriterien für Qualität: Einfache Hashfunktionen ) schnelles Auswerten von h(x) 2) wenige Kollisionen (unter realistischen Annahmen über die Schlüsselmenge S) Für ) entscheidend: Schlüsselformat FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Fall: Schlüssel sind natürliche Zahlen: U N Divisionsrestmethode: Multiplikationsmethode: U = {0,,...,u } Idee: Für 0 < ϑ < (ideal: ϑ irrational) h(x) = x mod m Hinweis: Sehr einfach, effizient. Nachteile: Unflexibel Bei strukturierten Schlüsselmengen (z.b. aus Strings übersetzte Schlüssel) erhöhtes Kollisionsrisiko Relativ sicher nur für Primzahlen m. Vorsichtsmaßnahme: m 2 k 20 für Zweierpotenzen 2 k. Für Produktionssysteme nicht sehr zu empfehlen. h(x) = ((ϑx) mod ) m. Dabei: (ϑx) mod = (ϑx) (ϑx). (Gebrochener Anteil von ϑx.) Beispiel: ϑ = φ = 2 ( 5 ) m = 00 FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

20 h(00) = ((00ϑ) mod ) 00 = (6, mod ) 00 = 80 h(0) = ((0ϑ) mod ) 00 = (62, mod ) 00 = 42 Man kann zeigen: Mit diesem ϑ werden aufeinanderfolgende Schlüssel (x,x +,...,x + q ) sehr gut in [m] verteilt. Diskrete Version : mit a ungerade und ϑ a/2 k. h a (x) = (ax mod 2 k ) div2 k l Auswertung ohne Division (sehr effizient): a * x = ax h(x) l Bits FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Fall: Schlüssel sind Strings: U Seq(Σ) Σ: Alphabet endliche nichtleere Menge. Beispiel: Σ = ASCII-Alphabet = {0,} 8 = {0,,...,255} Schlüssel: x = (c,...,c r ),c,...,c r Σ. Stets möglich: num : Σ {0,..., Σ } übersetzt Alphabetzeichen in Zahlen. Möglich, nicht sehr zu empfehlen: ransformation von Schlüssel x in Zahl ˆx = n(x) als neuen Schlüssel. Dann: x h(ˆx). Kollisionen n(x) = n(y) nie auflösbar! Häufig: Ineffiziente Auswertung. Besser: An Schlüsselformat x = (c,...,c r ) angepasste Hashfunktionen. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

21 Lineare Funktionen über Körper Z p : m = p Primzahl mit p > Σ, also 0 num(c) < p. Wähle Koeffizienten a,...,a r {0,...,p }. ( r ) h(c c r ) = a i num(c i ) mod p. Vorteile: i= Rechnung nur mit Zahlen < m 2 (wenn man nach jeder Multiplikation/Addition modulo m reduziert); Sehr effizient; heoretisch nachweisbares gutes Verhalten, wenn a,...,a r aus {0,,...,p } zufällig gewählt wurden. Lineare Funktionen über Z 2 -Vektorraum {0,} n U = Σ r, mit Σ = {0,...,s }. m = 2 l mit l w (w: Wortlänge, z.b. w = 32). [m] entspricht {0,} l. Repräsentation der Hashfunktion h: Array A[..r,0..s ] mit Einträgen aus {0,} w. h(c c r ) = die ersten l Bits von A[,num(c )] A[r, num(c r )] FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD Dabei: ist bitweises XOR, auf ganzes Wort angewendet. (Maschinenoperation effizient!) Beispiel: w {}}{ a i XOR b i Zahlenbeispiel: r = 20 Zeichen pro Wort. w = 32, Σ = ASCII-Alphabet = {0,} 8. A[..r,0..s ] hat rs = Einträge. Sinnvoll für große Hashtabellen. = a i b i {, ai b = i 0, a i = b i Vorteile: Sehr schnelle Auswertung ( ebenso schnell wie +); heoretisch nachweisbares gutes Verhalten, wenn Einträge von A zufällig sind; Dasselbe kann für m = 2 4,2 5,2 6,...,2 w benutzt werden. Ideal für die Kombination mit der Verdopplungsstrategie: Wählen einer neuen Hashfunktion für doppelt so große abelle entspricht dem Erhöhen von l um ; die Einträge in A bleiben unverändert. FG KuEA, U Ilmenau AuD FG KuEA, U Ilmenau AuD

22 Wiederholen: GdP-Folien über Hashing. Lineares Sondieren Quadratisches Sondieren Double Hashing FG KuEA, U Ilmenau AuD