Informatik I 4. Kapitel Rainer Schrader Zentrum für Angewandte Informatik Köln 21. Mai 2008 1 / 55 2 / 55 Szenario Suchen in Daten gehört zu den wichtigsten Operationen etwa Suchen nach: Stichworten in Lexika Telefonnummern, Kontonummern, Kfz-Kennzeichen Dateinamen, Absender von emails,... die Daten liegen als sequentielle lineare Listen vor die Daten werden über Schlüssel k N identifiziert nur Schlüsselvergleiche sind erlaubt (elementare Suchverfahren) in späteren Kapiteln: Suchen auf Bäumen Suche durch arithmetische Berechnungen der Adressen temporäre Annahme: keine zwei Schlüssel sind gleich 3 / 55 4 / 55
Gliederung das Auswahlproblem (Medianbestimmung) Suchen in unsortierten Listen Suchen in sortierten Listen selbstorganisierende Listen Auswahlproblem gegeben: n Schlüssel (Datensätze), ein k n, gesucht: der k -kleinste Schlüssel Spezialfall: bestimme den Median: k = n 2 5 / 55 6 / 55 einfache Lösung: suche den kleinsten Schlüssel in linearer Zeit lösche dieses Element suche den kleinsten Schlüssel in den verbleibenden Daten lösche dieses Element,... O(kn) Schritte (O(n 2 ) für das Medianproblem) besser: baue einen min-heap aus den Daten lösche das minimale Element repariere Heap durch Versickern lösche das minimale Element,... besserer Ansatz (bestimme das k -kleinste Element) wähle ein Pivotelement A(i) (wie in Quicksort) teile die Schlüssel auf in S 1 = {A(j) : A(j) < A(i)} S 2 = {A(j) : A(j) > A(i)} suche rekursiv im richtigen Teil weiter: falls S 1 = k 1, dann ist A(i) das gesuchte Element falls S 1 k, suche das k -kleinste Element in S 1 falls S 1 < k 1, suche das k 1 S 1 -kleinste Element in S 2 O(n + k log n) Schritte (O(n log n) für das Medianproblem) 7 / 55 8 / 55
angenommen für ein ε > 0 gilt: wir können A(i) stets so wählen, dass: S 1 εn S 2 εn dann wird die Rekursion auf höchstens (1 ε)n n durchgeführt damit folgt für die Laufzeit T : T (n) T (1 ε)n + cn. Satz T (n) dn für d = c. ε Beweis: Per Induktion folgt: T (n) T (1 ε)n + cn. T (n) T (1 ε)n + cn d (1 ε)n + cn c (1 ε)n + cn ε = dn 9 / 55 10 / 55 Idee damit hätten wir einen linearen Algorithmus zur Bestimmung des k -kleinsten Elements wir müssen nur immer mindestens einen konstanten Teil abspalten teile die n in Fünfergruppen auf (bis auf einen Rest von bis zu 4 n) sortiere diese Gruppen und nimm jeweils das mittlere Element (Median) bestimme rekursiv den Median der n 5 Mediane, benutze dieses Element als Pivotelement sei x der Median der Mediane mit Ausnahme der Gruppe, die x enthält, und evtl. der letzten gilt: eine Gruppe, deren Median kleiner ist als x, enthält 3, die kleiner sind als x eine Gruppe, deren Median größer ist als x, enthält 3, die größer sind als x damit ist die Anzahl der, die kleiner sind als x, mindestens 1 l n m ı εn = 3( 2) 3 2 5 10 n 6. entsprechendes gilt für die Mindestanzahl der, die kleiner als x sind 11 / 55 12 / 55
Illustration: 1 2 n+5 n 10 5 Pivotelement: Median der Mediane Mediane der Gruppen mit einem ähnlichen Argument lässt sich zeigen, dass das Pivotelement zufällig gewählt werden kann: ein Element x heiße zentral, falls höchstens 1 8 1 8 damit sind 3 4 größer sind als x, und kleiner sind als x aller zentral mit hoher Wahrscheinlichkeit ist ein zufällig gewähltes Element zentral und das Verfahren hat eine erwartete Laufzeit, die linear ist. 3 10 n 6 3 10 n 6 13 / 55 14 / 55 Die Listen seien als Feld A implementiert mit n n in den Positionen 1... n. Gliederung das Auswahlproblem (Medianbestimmung) Suchen in unsortierten Listen Suchen in sortierten Listen selbstorganisierende Listen Sequentielle Suche (wie in Kapitel 1) sequential_search (A, n, k) // durchsucht A[1..n] nach n mit Schlüssel k, // liefert Position eines solchen, falls existent, sonst 0 A(0) = k i = n+1 repeat i = i-1 until A(i) = k end do return i 15 / 55 16 / 55
Gliederung Analyse des Suchens in unsortierten Listen offensichtlich gilt: C min (n) = 1, C max (n) = n + 1, C avg (n) = 1 n P n i=1 i = n+1 2 für eine erfolgreiche Suche. Analog für verkettete Listen. das Auswahlproblem (Medianbestimmung) Suchen in unsortierten Listen Suchen in sortierten Listen binäre Suche Fibonacci-Suche exponentielle Suche weitere Suchverfahren selbstorganisierende Listen 17 / 55 18 / 55 nichtrekursive Implementierung Ab jetzt nehmen wir an, dass die Liste sortiert ist, also: A(1) A(2) A(n) Binäre Suche Divide and Conquer: vergleiche mit dem Schlüssel in der Mitte der Liste, Treffer: STOP, kleiner : durchsuche links von der Mitte, größer : durchsuche rechts von der Mitte. binary_search(a, l, r, k) // sucht nach Schlüssel k im Bereich A[l..r], // liefert 0, falls nicht vorhanden m = (l+r)/2 while ((A(m) k) und (l r)) do if (k < A(m)) r = m - 1 else l = m + 1 end if m = (l+r)/2 end while if (k = A(m)) return m else return 0 end if 19 / 55 20 / 55
Analyse der binären Suche: best case: C min (n) = Θ(1) (sofortiger Treffer). Beispiel: n = 7 = 2 3 1 (k = 3): der allgemeine Fall: Position 1 2 3 4 5 6 7 wie lange dauert es, ein Element an Position 1 i n zu finden? vereinfachende Annahmen: n = 2 k 1 für geeignetes k (d.h. k = log(n + 1)) eine Zeiteinheit (ZE) für Bestimmung der Mitte Entscheidung, ob links weiter oder rechts weiter oder Treffer sofortiger Treffer: 1 ZE Treffer in der Mitte links oder rechts: 2 ZE... Zeiteinheiten 3 2 3 1 3 2 3 1 ZE für mittleres Element 2 ZE für mittleres in linker Hälfte 2 ZE für mittleres in rechter Hälfte 3 ZE für die vier anderen worst case: k = log(n + 1) ZE, C max (n) = Θ(log n) (erfolgreich oder -los) 21 / 55 22 / 55 average case: Lemma Anzahl ZE Positionen Produkt aufsummiert 1 1 1 1 2 2 4 5 3 4 12 17 4 8 32 49.. k 2 k 1 k 2 k 1 P k i=1 i 2i 1 ergibt eine durchschnittliche Zeit von: 1 n. kx i 2 i 1. i=1. kx i 2 i 1 = (k 1) 2 k + 1. i=0 Beweis: per Induktion k = 1 : 1 = (k 1) 2 k + 1. k > 1 : kx Xk 1 i 2 i 1 = i 2 i 1 + k 2 k 1 i=0 i=0 = (k 2) 2 k 1 + 1 + k 2 k 1 (per Induktion) = 2k 2 k 1 2 2 k 1 + 1 = k 2 k 1 2 k + 1 = (k 1) 2 k + 1. 23 / 55 24 / 55
Mit k = log(n + 1) folgt: C avg = 1 n kx i 2 i 1 i=0 Gliederung das Auswahlproblem (Medianbestimmung) = 1 n (k 1) 2k + 1 = 1 h i (log(n + 1) 1)(n + 1) + 1 n = 1 h i (n + 1) log(n + 1) n n = n + 1 n = log(n + 1) + log(n + 1) 1 log(n + 1) n 1 n log(n + 1) 1 Suchen in unsortierten Listen Suchen in sortierten Listen binäre Suche Fibonacci-Suche exponentielle Suche weitere Suchverfahren selbstorganisierende Listen C avg (n) = Θ(log n) und nur eine Zeiteinheit weniger als im worst-case. 25 / 55 26 / 55 Grundidee wie bei der Binärsuche aber andere asymmetrische Aufteilung Aufteilung erfolgt anhand der Fibonacci-Zahlen keine Divisionen zur Bestimmung der Mitte, nur Additionen und Subtraktionen Fibonacci-Zahlen sind durch folgende Rekursion gegeben: F 0 = 0 F 1 = 1 F m = F m 1 + F m 2 für m 2 Beispiel: m 0 1 2 3 4 5 6 7 8 9 10 11 12 F m 0 1 1 2 3 5 8 13 21 34 55 89 144 27 / 55 28 / 55
Fibonacci-Zahlen sind durch folgende Rekursion gegeben: F 0 = 0 F 1 = 1 F m = F m 1 + F m 2 für m 2 vereinfachende Annahme: sei n = F m 1 für geeignetes m dann ist F m 1 = F m 2 1 + F m 1 1 + 1 das Intervall [1,..., F m 1] zerfällt an der Position F m 2 in zwei Intervalle der Länge F m 2 1 und F m 1 1. Lemma F m = 1» «m «m 1 + 5 1 5 1 = 5 2 2 5 1 + 5 2 «m + 1. 2 Beispiel für (m = 8): 1 8 = i = Fm 2 20 = n = Fm 1 Beweis: per Induktion. Hierbei steht für Abrunden. 7 = Fm 2 1 12 = Fm 1 1 29 / 55 30 / 55 Beispiel für (m = 8): 1 8 = i = Fm 2 20 = n = Fm 1 1 8 = i = Fm 2 20 = n = Fm 1 7 = Fm 2 1 12 = Fm 1 1 7 = Fm 2 1 12 = Fm 1 1 Fibonacci-Suche Sei n = F m 1 für geeignetes m 2. setze i = F m 2 vergleiche den zu suchenden Schlüssel k mit A(i): A(i) = k : Suche erfolgreich A(i) > k : suche im linken Bereich mit F m 2 1 n A(i) < k : suche im rechten Bereich mit F m 1 1 n Suche im rechten Bereich: Suche im linken Bereich: 1 5 = i = Fm 3 12 = Fm 1 1 4 = Fm 3 1 7 = Fm 2 1 1 3 = i = Fm 4 7 = Fm 2 1 2 = Fm 4 1 4 = Fm 3 1 31 / 55 32 / 55
nach dem letzten Lemma ist F m c 1.618 m mit einer Konstanten c Analyse der Fibonacci-Suche wir starten mit einem Intervall der Länge F m 1 das nächste Intervall hat eine Länge von höchstens F m 1 1... das j-te Intervall hat eine Länge von höchstens F m j+1 1 das Verfahren bricht ab, sobald F m j+1 1 = 1 m j + 1 = 3 damit benötigen wir höchstens m Schlüsselvergleiche für n + 1 = F m c 1.618 m benötigen wir maximal m Vergleiche damit folgt: C max (n) = Θ(log 1.618 (n + 1)) = Θ(log 2 n) es gilt auch (ohne Beweis): C avg (n) = Θ(log 2 n). damit haben wir die gleiche Größenordnung wie bei der Binärsuche, aber hier haben wir keine Divisionen (Shifts), nur Additionen und Subtraktionen 33 / 55 34 / 55 programmtechnische Umsetzung für n = F m 1 wir speichern ein Paar (f 1, f 2 ) = (F m 3, F m 2 ) wir testen an der Stelle f 2 falls Suche im rechten Intervall fortgesetzt wird (Länge F m 1 1): ist f 1 = 0 : F m 3 = 0, F m 2 = 1 F m 1 1 = F m 3 + F m 2 1 = 0 d.h. die Suche bricht ab andernfalls merken wir uns (f 1, f 2) = (F m 4, F m 3 ) = (f 2 f 1, f 1 ) programmtechnische Umsetzung für n = F m 1 wir speichern ein Paar (f 1, f 2 ) = (F m 3, F m 2 ) wir testen an der Stelle f 2 falls Suche im linken Intervall fortgesetzt wird (Länge F m 2 1) : ist f 2 = 1 F m 2 1 = 0 d.h. die Suche bricht ab andernfalls merken wir uns (f 1, f 2) = (F m 5, F m 4 ) = (2f 1 f 2, f 2 f 1 ) 35 / 55 36 / 55
fibonacci_search(a, m, k) // sucht für n = F(m)-1 im Bereich A[1..n] nach Position // mit Schlüssel k; liefert 0, falls nicht vorhanden pos = -1; f1 = F(m-3); f2 = F(m-2); i = f2; while (pos < 0) do if (k > A(i)) // Durchsuche den oberen Bereich if (f1 = 0) then pos = 0 // nicht vorhanden else i = i + f1 t = f1 f1 = f2 - f1 f2 = t end if else if (k < A(i)) // Durchsuche den unteren Bereich if (f2 = 1) then pos = 0 // nicht vorhanden else i = i - f1 f2 = f2 - f1 f1 = f1 -f2 end if else pos = i end if return pos // gefunden 37 / 55 Gliederung das Auswahlproblem (Medianbestimmung) Suchen in unsortierten Listen Suchen in sortierten Listen binäre Suche Fibonacci-Suche exponentielle Suche weitere Suchverfahren selbstorganisierende Listen 38 / 55 Szenario: n ist sehr groß, oder unbekannt Dann ist es sinnvoll, zuerst einen Bereich zu bestimmen, in dem ein gegebener Schlüssel liegen muss. Idee der exponentiellen Suche wir verdoppeln in jedem Schritt den Suchbereich bis wir ein Intervall gefunden haben mit A( i 2 ) < k A(i) in diesem Intervall suchen wir binär weiter. exponential_search(a, 1, n, k) // suche nach Position mit Schlüssel k im Bereich A[1..n] if ((k < A(1) or k > A(n))) return 0 else i = 1 while ((k > A(i)) und (i < n)) do i = i + i if (i > n) i = n return binary_search(a,i/2,i,k) 1 2 4 8 16 39 / 55 40 / 55
Analyse der exponentiellen Suche Annahme: alle Schlüssel sind verschieden, positiv und ganzzahlig. Schlüssel wachsen mindestens so schnell wie die Indizes der wird in der while-schleife d -mal verdoppelt, so gilt 2 d 1 A(2 d 1 ) < k < A(2 d ) d < 1 + log k = Θ(log k ) Vergleiche der Suchbereich enthält dann höchstens 2 d 1 < k Schlüssel Θ(log k ) Vergleiche in binary_search im worst case die Gesamtlaufzeit beträgt somit Θ(log k ). sinnvoll, wenn k n gilt. Gliederung das Auswahlproblem (Medianbestimmung) Suchen in unsortierten Listen Suchen in sortierten Listen binäre Suche Fibonacci-Suche exponentielle Suche weitere Suchverfahren selbstorganisierende Listen 41 / 55 42 / 55 Interpolationssuche sucht man im Telefonbuch den Namen Ackermann, so wird man vorne aufschlagen, bei Knuth eher in der Mitte die Sondierung wird somit in Abhängigkeit von der Verteilung der Namen gewählt m Binärsuche testet stets in der Mitte des Intervalls m = ll + 12 (r l) die Interpolationssuche interpoliert die Schlüssel linear zwischen den Intervallgrenzen A(l) A(r) m = l m l + k A(l) (r l). A(r ) A(l) Satz Sind die n Schlüssel unabhängig und gleichverteilt aus einem Intervall I, so beträgt die mittlere Suchzeit O(log log n). Aber der worst-case beträgt Θ(n) und ist damit schlechter als binäre Suche: Beispiel: A(i) = n für 1 i < n A(n) = 2n k = n + 1 dann liefert die Interpolationssuche m = l + k A(l) ı (r l) = 1 + n + 1 n ı (n 1) = 2 A(r ) A(l) 2n n und danach m = 3, 4, 5... l r 43 / 55 44 / 55
quadratische Binärsuche Versuch, unter Beibehaltung der guten mittleren Laufzeit die worst-case-laufzeit zu verbessern: seien wie vorher A(1) <... < A(n) zusätzlich A(0) < A(1), A(n + 1) > A(n) führe einen Schritt der Interpolationssuche aus teile das verbleibende Suchintervall in Subintervalle der Größe n auf führe lineare Suche auf diesen Subintervallen duch und bestimme das Subintervall, in dem x liegen müsste wende das Verfahren rekursiv auf dieses Subintervall an. setze l := 0, r := n + 1 und rufe quadratische Binärsuche(A,k,l,r) auf. quadratische Binärsuche (A,k,l,r) l m (1) setze aktuell := l + k A(l) (r l) A(r ) A(l) (2) ist k = A(aktuell), stop. (3) ist k > A(aktuell), setze l := aktuell + 1 (4) ist k < A(aktuell), setze r := aktuell 1 (5) bestimme durch lineare Suche ein i mit A(l + (i 1) n ˇ) k A(l + i n ˇ) (6) wende Verfahren rekursiv an auf das Intervall [l + (i 1) n ˇ, l + i n ˇ]. n n n n n 45 / 55 46 / 55 Es lässt sich zeigen: Lemma Seien die Schlüssel unabhängig und gleichverteilt über (A(0), A(n + 1)). Dann ist die mittlere Anzahl C der Vergleiche pro Programmaufruf der quadratischen Binärsuche höchstens 3. das Verfahren findet im Mittel nach drei Schritten das Intervall der Größe n, in dem k liegen müsste. Daraus lässt sich die mittlere Laufzeit abschätzen: Satz Unter der obigen Voraussetzung betragen die mittleren Kosten T avg (n) der quadratischen Binärsuche O(log log n). Beweis: Es gilt: T avg (1) 1, T avg (2) 2 und T avg (n) C + T avg ( n) für n 3. Wir zeigen per Induktion T avg (n) 2 + C log log n: T avg (n + 1) C + T avg ( n + 1) = C + 2 + C log log((n + 1) 1 2 ) = C + 2 + C log 1 log(n + 1) 2 = 2 + C log log(n + 1) Im schlimmsten Fall beträgt die Suchzeit n 1 2 + n 1 4 +... = O( n) Einheiten. 47 / 55 48 / 55
exponentielle und binäre Suche 2. Versuch, unter Beibehaltung der guten mittleren Laufzeit die worst-case-laufzeit zu verbessern: seien wie vorher A(1) <... < A(n) zusätzlich A(0) < A(1), A(n + 1) > A(n) führe einen Schritt der Interpolationssuche aus zerlege das verbleibende Suchintervall in Subintervalle der Größe n, 2 n, 4 n,... 2 i n auf teile das verbleibende Suchintervall in Subintervalle der Größe n auf führe binäre Suche auf diesen Subintervallen durch und bestimme das Subintervall, in dem x liegen müsste wende das Verfahren rekursiv auf dieses Subintervall an. setze l := 0, r := n + 1 und rufe quadratische Binärsuche(A,k,l,r) auf. exponentielle und binäre Suche (A,k,l,r) l m (1) setze aktuell := l + k A(l) (r l) A(r ) A(l) (2) ist k = A(aktuell), stop. (3) ist k > A(aktuell), setze l := aktuell + 1 (4) ist k < A(aktuell), setze r := aktuell 1 (5) bestimme: S(l + 2 i 1 n) < k S(l + 2 i n). (6) auf dem Intervall [l + 2 i 1 n, l + 2 i n] bestimme j durch binäre Suche mit S(l + (j 1) n) < k S(l + j n). (7) wende Verfahren rekursiv auf das Intervall [l + (j 1) n, l + j n] an 49 / 55 50 / 55 Gliederung das Auswahlproblem (Medianbestimmung) Satz Unter der obigen Voraussetzung gilt für die exponentielle und binäre Suche: die Anzahl der Vergleiche im schlechtesten Fall ist O(log n) die Anzahl der Vergleiche im Mittel ist O(log log n) ( da log i i) Suchen in unsortierten Listen Suchen in sortierten Listen binäre Suche Fibonacci-Suche exponentielle Suche weitere Suchverfahren selbstorganisierende Listen 51 / 55 52 / 55
Szenario: Datenstruktur: verkettete, unsortierte Listen wiederholte Suchanfragen unterschiedliche Häufigkeiten für die Schlüssel organisiere Liste so um, dass häufige Anfragen am Anfang der Liste Strategien: Bei jeder Anfrage an einen Schlüssel: vertausche Listenelement mit Element davor, oder erhöhe einen Anfragenzähler und sortiere nach fallendem Zähler, oder setze Element an die Spitze der Liste. 53 / 55 54 / 55 zur Suche haben wir bisher lediglich Vergleichsoperationen auf den Schlüsseln zugelassen wir werden im nächsten Kapitel arithmetische Operationen auf den Schlüsseln erlauben, um daraus die mögliche Position des Datums zu berechnen. 55 / 55