Algorithmen und Datenstrukturen 8. Vorlesung

Transkript

1 Algorithmen und Datenstrukturen 8. Vorlesung Martin Dietzfelbinger 2. Juni 2008 Beispiel eines N-MSB: Mehrweg-Such-Bäume Wurzel FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Mehrweg-Such-Bäume Variante Ein MSB-Knoten wird durch eine aufsteigend sortierte lineare Liste von Binärbaumknoten dargestellt. Jeder Knoten hat Platz für: Schlüssel, (Daten,) Zeiger auf Unterbaum, Zeiger auf nächsten in Liste. Im Knoten ist als Boolescher Wert vermerkt, ob es sich um den Knoten am Listenende handelt. (Im Bild: *.) Dieser Knoten hat zwei Zeiger auf Unterbäume. Elegant: Für die Suche kann man die gewöhnliche Suchprozedur für binäre Suchbäume benutzen. Mehrweg-Such-Bäume T: * 7 16 * * * * 9 * 12 * FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

2 2-3-Bäume Definition Ein Mehrweg-Suchbaum T heißt ein 2-3-Baum, wenn gilt: Beispiele: Leerer 2-3-Baum: 2-3-Baum mit 2 Ebenen: G O Level 1 (a) Jeder Knoten enthält 1 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 T 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 T haben dieselbe Tiefe. 2-3-Baum mit 3 Ebenen: A I L R Level 0 = Blattebene I Level 2 G O T Level 1 A H L M R S U Level 0 = Blattebene NB: Die Ebenen werden von den Blättern her nummeriert. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD L O T A M R U Kein 2-3-Baum (zu großer Grad). G A O L M R Kein 2-3-Baum (Blätter in verschiedenen Tiefen). 2-3-Bäume: Logarithmische Tiefe Proposition Die Tiefe eines 2-3-Baums mit n Einträgen ist mindestens log 3 (n +1) 1 und höchstens log(n +1) 1. [log 3 x 0.63 log 2 x.] Beweis: Übung. Level h h-1 G O A I L Kein 2-3-Baum (Leerer Unterbaum in Nicht-Blatt). 1 0 FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

3 2-3-Bäume: logarithmische Laufzeit Mitteilung Mit 2-3-Bäumen lassen sich die folgenden Operationen in Zeit O(log n) durchführen (wo n die gegenwärtig im Baum gespeicherte Anzahl von Schlüsseln ist): Suchen Einfügen Löschen split(t,a) (zerlege T in zwei Bäume, einer enthält alle Einträge >a, der andere alle Einträge a. join(t 1,T 2 ) (gegeben zwei Bäume T 1, T 2 mit x 1 <x 2 für alle x 1 in T 1, x 2 in T 2, konstruiere einen Baum T, der alle Schlüssel enthält. Details, Beweise: siehe Literatur Weitere balancierte Bäume... mit logarithmischer Tiefe und logarithmischen Operationszeiten: Bäume: Mehrwegsuchbäume mit 1, 2 oder 3 Schlüsseln pro Knoten (und 2, 3 oder 4 Unterbäumen). Rot-Schwarz-Bäume B-Bäume (für Hintergrundspeicher, Schlüssel, Daten, Zeiger eines Knotens füllen eine Seite im Hintergrundspeicher) Darstellung: siehe Literatur, für B-Bäume auch Vorlesung Datenbank-Implementierungstechniken. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD oder Hashing Schlüsseltransformationsverfahren... implementieren Wörterbücher... bieten Operationen in (erwarteter) konstanter Zeit Gegeben: Universum U (auch ohne Ordnung) und Wertebereich R. Ziel: Implementiere Wörterbuch oder dynamische (partielle) Abbildung f : S R, wos U endlich Werden sehen: Erreichbar ist Zeit O(1) pro Operation im Durchschnitt unabhängig vom Umfang der Datenstruktur! Gegensatz Bäume: Zeit O(log(n)) pro Operation. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

4 T Grundansatz: h h: U [m] Speicherung von f : S R in m Plätzen einer Tabelle T[0..m 1]. Aus Schlüssel x U wird ein Index h(x) [m] berechnet. U : Universum der Schlüssel [m] ={0,...,m 1} : Indexbereich für Tabelle T x wird in h(x) umgewandelt/transformiert. Idealvorstellung: Speichere x und f(x) in Zelle T[j], woj = h(x). S U, S = n S U m 1 FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Beispiel: U = {A,...,Z, a,...,z} 3 Nichtleere Wörter aus lateinischen Buchstaben mit mindestens 3 Buchstaben: eine unendliche Menge! h : U {0,...,12} wird definiert durch wo h(c 1 c 2 c r )=num(c 3 )mod13, num(a) = num(a) = 0 num(b) =. num(b). = 1. num(z) = num(z) = 25 h(c 1...c r )=num(c 3 )mod13 x f(x) num(c 3 ) h(x) Januar Februar Maerz April Mai Juni Juli August September Oktober November Dezember FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

5 h(c 1...c r )=num(c 3 )mod13 Kollisionen! j (x, f(x)) 0 (Januar, 31) (Juni, 30) 1 (Februar, 28) 2 (September, 30) 3 (Maerz, 31) (April, 30) (August, 31) (Oktober, 31) 7 8 (Mai, 31) (November, 30) (Juli, 31) 11 (Dezember, 31) 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]. 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 1 = {Februar (1), Maerz (4), Mai (8), Juni (0), Juli (11), Dezember (12) } ist obiges h injektiv, nicht aber auf S 2 = {Januar (0), Mai (8), Juli (11), November (8) }. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Sprechweise: h perfekt für S : h S injektiv. Falls h perfekt für S: Speichere x bzw. (x, r) in Tabellenplatz T[h(x)]. lookup(x): Berechne j = h(x). (Dies sollte effizient möglich sein.) Prüfe, ob in T[j] 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, fortgeschrittene Konstruktionen.) Fall: h rein zufällig, S = n, S = {x 1,...,x n }. D. h.: Uniformitätsannahme (UF ): Werte h(x 1 ),...,h(x n ) in [m] 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. (UF ) tritt z. B. (näherungsweise) ein, wenn U endlich ist, S U rein zufällige Menge ist und h das Universum in gleich große Teile schneidet, d. h. h 1 ({j}) = U m oder = U m,j=0,...,m 1. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

6 Mit (UF ): Pr(keine Kollision) = = Pr(h ist injektiv auf {x 1,...,x n })= = m m m 1 m m 2 n +1 m =... m m (Für i =1,...,n ist die Wahrscheinlichkeit, dass h(x i ) in [m] {h(x 1 ),...,h(x i 1 )} liegt, genau m i+1 m.)... = 1 ( 1 1 ) ( 1 2 ) m m < e 0 e m 1 e m 2 e n 1 m (denn für x 0ist 1+x<e x ), also... ( 1 n 1 m = e n(n 1) 2m. ) Pr(h injektiv auf S) <e n(n 1) 2m. Wunsch: Linearer Platzverbrauch, also Auslastungsfaktor α = n m nicht kleiner als eine Konstante α 0,z.B.α 1 2 stets. Dann: Pr(h injektiv auf S) e α 0 (n 1) 2. Winzig für nicht ganz kleine n! Fazit: Kollisionen kommen vor. Kollisionsbehandlung ist notwendig. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Beispiel: T Hashing mit verketteten Listen : 1 1 Juni Februar September Maerz August November Juli Dezember Januar April Oktober Mai Hashing mit verketteten Listen engl.: chained hashing Auch: offenes Hashing, weil man Platz außerhalb von T benutzt. In Array T[0..m 1] werden Zeiger auf die Anfänge von m einfach verketteten linearen Listen L 0,...,L m 1 gespeichert. Liste L j enthält die Schlüssel x aus Behälter ( bucket ) B j = {x S h(x) =j}, gegebenenfalls mit Zusatzinformation, d. h. dem Wert r = f(x). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

7 Algorithmen(skizzen) empty(m): Erzeugt Array T[0..m 1] mit m NULL-Zeigern und legt h : U [m] fest. Kosten: Θ(m). Beachte: Man wählt h, ohne S zu kennen! lookup(x): Berechne j = h(x); suche Schlüssel x in Liste L j bei T[j]; falls Eintrag (x, r) gefunden: return r; ( erfolgreiche Suche ) sonst: return nicht vorhanden ( erfolglose Suche ) Kosten: O(1 + Zahl der Schlüsselvergleiche x = y? )... falls die Auswertung von h(x) und ein Schlüsselvergleich Zeit O(1) kostet. Kosten: Erfolglose Suche: B j Schlüsselvergleiche. Kosten: Erfolgreiche Suche: Kosten: Zwischen 1 und B j Schlüsselvergleiche, Kosten: Mittlere Anzahl: 1 2 (1 + B j ). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD insert(x, r): Kosten: Wie bei lookup. Berechne j = h(x); suche Schlüssel x in Liste L j bei T[j]; falls gefunden: ( erfolgreiche Suche ) ersetze Daten bei x durch r; sonst: ( erfolglose Suche: Normalfall! ) füge (x, r) in Liste T[j] ein. delete(x): Kosten: wie bei lookup. Berechne j = h(x); suche Schlüssel x in Liste L j bei T[j]; falls gefunden: ( erfolgreiche Suche, Normalfall! ) lösche Eintrag (x, f(x)); sonst: ( erfolglose Suche ) tue nichts. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

8 Ziel: Analysiere erwartete Kosten für lookup, insert, delete. Hierfür genügt: Analysiere erwartete Anzahl der Schlüsselvergleiche. Vorausgesetzt: Irgendeine Quelle für Zufall. (Dazu später mehr.) Pr(A): Wahrscheinlichkeit für Ereignis A. E(X): Erwartungswert der Zufallsvariablen X. Abgeschwächte Uniformitätsannahme (UF 2 ) : Szenario: Menge S = {x 1,...,x n } von n Schlüsseln in Struktur gespeichert. Nun: Suche nach y U. α = n m : der (aktuelle) Auslastungsfaktor. Fall y/ S erfolglose Suche. Fall y S erfolgreiche Suche. Wir mitteln über alle Fälle y = x 1,...,y = x n. Für je 2 Schlüssel x z in U gilt: Pr(h(x) =h(z)) 1 m Später: Wann ist diese Annahme erfüllt? Wenn Hashwerte rein zufällig sind:... = 1 m. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Fall y/ S Erfolglose Suche. Definiere Zufallsgrößen/Zufallsvariable, für alle x, z U: { 1, falls h(x) =h(z), Y x,z := 0, falls h(x) h(z). Erwartete Listenlänge: E( B h(y) )= x S E(Y x,y ) (UF 2) x S 1 m = n m = α. Nach (UF 2 ): E(Y x,z )=Pr(h(x) =h(z)) 1 m. Anzahl der Schlüsselvergleiche/Listenlänge = Aktuelle Länge der bei der Suche zu durchlaufenden Liste = B h(y) = {x S h(x) =h(y)} = x S Y x,y. Dabei ist B h(y) eine Zufallsvariable! Proposition Bei Hashing mit verketteten Listen gilt unter der Annahme (UF 2 ) folgendes: Die erwartete Anzahl von Schlüsselvergleichen bei erfolgloser Suche ist höchstens α. Die erwartet Zeit für eine erfolglose Suche ist O(1 + α). Fazit: Wenn α α 1, α 1 konstant (z.b. α 1 =2), dann ist die erwartete Zeit für eine erfolglose Suche O(1). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

9 Fall y S Erfolgreiche Suche. Wie viele Schlüsselvergleiche im erwarteten Fall (nach (UF 2 ))? Gemittelt über alle Fälle y = x, x S (jeweils W. 1 n )! Wir nehmen an (keine wesentliche Annahme): Einfügereihenfolge ist x 1,...,x n, Elemente werden beim Einfügen ans Listenende gesetzt. Im Fall y = x i wird y mit genau Y xk,y 1 k i Mittelung von 1 k i Y x k,y über alle i: 1 n 1 i n 1 k i Y xk,x i =1+ 1 n 1 k<i n Y xk,x i. Der Erwartungswert dieser Größe ist höchstens (mit (UF 2 )): 1+ 1 n 1 k<i n ( ) 1 n 1 m =1+1 n 2 m =1+n 1 2m < 1+α 2. Listenelementen verglichen. (In der Liste L h(y), vor oder gleich y.) FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Proposition Bei Hashing mit verketteten Listen gilt unter der Annahme (UF 2 ) folgendes: Die erwartete (mit (UF 2 )) mittlere (über die Einträge x 1,...,x n gemittelte) Anzahl von Schlüsselvergleichen bei erfolgreicher Suche ist höchstens 1+ α 2. Der erwartete Zeitbedarf für eine erfolgreiche Suche ist O(1 + α). Fazit: Wenn α α 1, α 1 konstant (z. B. α 1 =2), dann ist die erwartete Zeit für eine erfolgreiche Suche O(1). Wie erreicht man α α 1 bei wachsender, am Anfang unbekannter, Schlüsselanzahl? Verdoppelungsstrategie empty(m): Anfangs-Tabellengröße m oder empty(): Anfangs-Tabellengröße m 0 (fester Wert) Variable load enthält aktuelle Anzahl von Schlüsseln. empty(m): load 0, insert(x, r) mit x neu: load load +1, delete(x) mit x vorhanden: load load 1. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

10 Verdoppelungsstrategie (Forts.) Wenn bei insert(x, r) (mit x neu) load den Wert α 1 m überschreitet: Erzeuge neue Tabelle T neu der Größe 2m. Erzeuge neue Hashfunktion h neu : U [2m]. Übertrage Einträge aus alten Listen in Listen zu Tabelle T neu, gemäß neuer Hashfunktion. Dabei Einfügen am Listenanfang ohne Suchen. (Wissen: Alle Schlüssel sind verschieden!) Kosten: O(m) im schlechtesten Fall. Benenne T neu in T und h neu in h um. Satz Sei α 1 fest. Wenn die verwendeten Hashfunktionen (UF 2 ) erfüllen, dann gilt für das skizzierte Verfahren für Hashing mit Listen mit Verdoppelungsstrategie: (a) Die erwartete Anzahl der Schlüsselvergleiche für erfolglose bzw. erfolgreiche Suche sind α 1 bzw. 1+ α 1 2. (b) Die Gesamtkosten für sämtliche Verdopplungen sind durch O(ñ) (schlechtester Fall) beschränkt; dabei ist ñ die maximale Anzahl der jemals gleichzeitig in der Datenstruktur vorhandenen Schlüssel (maximaler Wert in load). (c) Der Gesamtplatzbedarf ist O(ñ). (Analyse der Verdoppelungsstrategie wie bei Stacks.) FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Kriterien für Qualität: Einfache Hashfunktionen 1) Zeit für Auswertung von h(x) (Schnell!) 2) Wahrscheinlichkeit für Kollisionen (unter realistischen Annahmen über Schlüsselmenge S). (Klein, am besten c/m für c konstant.) Für 1) entscheidend: Schlüsselformat. 1. Fall: Schlüssel sind natürliche Zahlen: U N. Divisionsrestmethode: h(x) =x mod m Hinweis: Sehr einfach, recht 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. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

11 Multiplikationsmethode: U N Idee: Für 0 < ϑ < 1 (ideal: ϑ irrational) h(x) = ((ϑ x) mod1) m. Dabei: (ϑ x) mod1=(ϑ x) (ϑ x). (Gebrochener Anteil von ϑ x.) h(x) = ((ϑ x) mod1) m. ( ) Beispiel: ϑ =Φ 1= ,618...; m = 100. h(10) = ((ϑ 10) mod1) 100 = (6, mod 1) 100 = 0, = 18 h(11) = ((ϑ 11) mod1) 100 = (6, mod 1) 100 =79 ϑ: theta. h(12) = ((ϑ 12) mod1) 100 = (7, mod 1) 100 =41 Man kann zeigen: Mit diesem ϑ werden aufeinanderfolgende Schlüssel (x, x +1,...,x+ q 1) sehr gut in [m] verteilt. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Diskrete Version der Multiplikationsmethode: U =[2 k ] und m =2 l. h a (x) =(ax mod 2 k ) div 2 k l mit a [2 k ] ungerade und ϑ a/2 k. Auswertung ohne Division (Shifts, Bitmasken sehr effizient): a k Bits x k Bits ax * = 2k Bits 1 h ( x) l Bits 2. Fall: Schlüssel sind Strings/Wörter: U Seq(Σ) Σ: Alphabet endliche nichtleere Menge. Seq(Σ): Menge aller endlichen Folgen von Elementen von Σ: Wörter über Σ. Beispiel: Σ= ASCII-Alphabet = {0, 1} 8 = {0, 1,...,255}. Schlüssel: x =(c 1,...,c r )=c 1...c r, c 1,...,c r Σ. Stets möglich: num :Σ 1 1 {0,..., Σ 1} übersetzt Alphabetzeichen (Buchstaben) in Zahlen. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

12 Möglich, nicht sehr zu empfehlen: Transformation von Schlüssel x in Zahl ˆx = n(x) als neuen Schlüssel, dann: x h(ˆx). Beispiel: h(c 1...c r )=(num(c 3 )) mod 13, hier ˆx = num(c 3 ) }{{} x x num(c 3 ) h(x) Januar Juni Kollisionen n(x) =n(y) nie auflösbar! Wenn n injektiv: Ineffiziente Auswertung von h(ˆx). Besser: An Schlüsselformat x = (c 1,...,c r ) angepasste Hashfunktionen. Lineare Funktionen über Körper Z p : m = p Primzahl mit p> Σ, also 0 num(c) <p. Wähle Koeffizienten a 1,...,a r {0,...,p 1}. ( r ) h(c 1 c r )= a i num(c i ) mod p. Vorteile: i=1 Rechnung nur mit Zahlen <m 2 (wenn man nach jeder Multiplikation/Addition modulo m reduziert); Sehr effizient; Theoretisch nachweisbares gutes Verhalten, wenn a 1,...,a r aus {0, 1,..., p 1} zufällig gewählt wurden. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Geschlossenes Hashing... oder offene Adressierung. Speichere alle Schlüssel in Array (Hashtabelle) T[0..m 1]. Speicherort von x nicht nur durch h(x) bestimmt offen. einfach praktisch viel verwendet kein Platz für Zeiger und leere Plätze in Zeiger-Array vermeidet Zeitaufwand für dynamische Erzeugung von Listenelementen schnell: O(1) Zeit (erwartet) für Wörterbuchoperationen. zur Ausführungszeit Einfachstes Verfahren mit Lineares Sondieren ( 1 1 FG KTuEA, TU Ilmenau AuD

13 Einfachstes Verfahren mit Lineares Sondieren ( Einfachstes Verfahren mit Lineares Sondieren ( 1 1 Januar (4) 1 1 Januar Februar (4) (5) Einfachstes Verfahren mit Lineares Sondieren ( Einfachstes Verfahren mit Lineares Sondieren ( 1 1 Januar Februar Maerz (4) (5) (8) 1 1 Maerz April (8) (8)

14 Einfachstes Verfahren mit Lineares Sondieren ( Einfachstes Verfahren mit Lineares Sondieren ( 1 1 Maerz (8) April Mai (8) (12) 1 1 Juni (4) Maerz (8) April (8) Mai (12) Einfachstes Verfahren mit Lineares Sondieren ( Einfachstes Verfahren mit Lineares Sondieren ( 1 1 Juli (2) Juni (4) Maerz (8) April (8) Mai (12) 1 1 Juli (2) Juni (4) Maerz (8) April August (8) (10) Mai (12)

15 Einfachstes Verfahren mit Lineares Sondieren ( Einfachstes Verfahren mit Lineares Sondieren ( 1 1 Juli (2) Juni (4) September (6) Maerz (8) April (8) August (10) Mai (12) 1 1 Juli (2) Juni (4) September (6) Maerz (8) April (8) August (10) Oktober (10) Mai (12) Einfachstes Verfahren mit Lineares Sondieren ( Einfachstes Verfahren mit Lineares Sondieren ( 1 1 November (12) Juli (2) Juni (4) September (6) Maerz (8) April (8) August (10) Oktober (10) Mai (12) 1 1 November (12) Juli (2) Dezember (3) Juni (4) September (6) Maerz April (8) (8) August (10) Oktober (10) Mai (12) FG KTuEA, TU Ilmenau AuD

16 empty(m): Lege leeres Array T[0..m 1] an. Arrayeintrag: (Schlüssel,Wert (in R)) oder leer. Initialisiere alle Plätze T[j] mit leer. Initialisiere load mit 0, maxload mit Wert <m. insert(x, r): j h(x); Finde erstes l in der Folge j, (j +1)modm, (j +2)modm,... mit T[l].key = x oder T[l] = leer. Im Fall T[l].key = x: ( erfolgreiche Suche ) T[l].data r; Im Fall T[l] = leer: ( erfolglose Suche ) Falls load = maxload: Überlaufbehandlung (z. B. Verdopplung von T, Neustart von insert(x, r)); Sonst: T[l] (x, r); load++. lookup(x): j h(x); Finde erstes l in der Folge j, (j +1)modm, (j +2)modm,... mit T[l].key = x oder T[l] = leer. Im Fall T[l].key = x: return T[l].data. ( erfolgreiche Suche ) Im Fall T[l] = leer: return nicht vorhanden. ( erfolglose Suche ) Korrektheit der Suche: Bei lookup(x) werden genau dieselben Zellen von T untersucht wie beim Einfügen von x. Da kein Element bewegt/gelöscht wird, wird auf diese Weise die Zelle, in der x sitzt, wieder erreicht, falls vorhanden oder eine leere Zelle wir müssen nur sicherstellen, dass immer eine leere Zelle vorhanden ist, also load m 1 ist. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Erinnerung: Große Uniformitätsannahme (UF ): Die Werte h(x 1 ),...,h(x n ) sind rein zufällig. Proposition Bei linearem Sondieren in einer Tabelle der Größe m mit Schlüsselmenge S = {x 1,...,x n } gilt, mit α = n m : Die erwartete (nach (UF )) Anzahl von Schlüsselvergleichen bei erfolgloser Suche nach y/ S ist 1 ( ) (1 α) 2. Die erwartete (nach (UF )) mittlere (über x 1,...,x n ) Anzahl von Schlüsselvergleichen bei erfolgreicher Suche nach y S ist 1 ( 1+ 1 ). 2 1 α Nur von α, nicht von n, m abhängig! FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

17 Lineares Sondieren Anzahl Vergleiche α erfolglos erfolgreich Erwarteter Aufwand ist also O(1), falls α α 0 für eine Konstante α 0 < 1. Erwartete Anzahl von Schlüsselvergleichen bei linearem Sondieren: erfolglose Suche erfolgreiche Suche α 1 2 (1 + 1 (1 α) 2 ) 1 2 ( α ) 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 FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Ergebnisse für lineares Sondieren: Eine einzelne erfolglose Suche wird z. B. bei zu 90% gefüllter Tabelle schon recht teuer. Bei vielen erfolglosen Suchen in einer nicht veränderlichen Tabelle (anwendungsabhängig!) sind diese Kosten nicht tolerierbar. α 0,6 oder α 0,7 liefert jedoch akzeptable Kosten. Die (über y S) gemittelte Einfüge-/Suchzeit ist dagegen sogar bei 90% gefüllter Tabelle noch erträglich.!!! Lineares Sondieren passt perfekt zu Cache-Architekturen und ist deswegen auch in der Praxis sehr schnell. (Bei einem Cachefehler wird eine ganze Zeile geholt mehrere aufeinanderfolgende Wörter aus T). Verdoppelungsstrategie bei linearem Sondieren: Verdopple die Tabelle, sobald der Auslastungsfaktor α = n/m einen Wert von α 0 übersteigt z.b. α 0 =0,75 oder α 0 =0,8. Empfehlung: Kombiniere lineares Sondieren mit einer guten universellen Hashklasse. Nicht auf die Zufälligkeit von S vertrauen! FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD