• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Boyer-Moore-Algorithmus
 

Boyer-Moore-Algorithmus

on

  • 12,231 views

Einführung in den Boyer-Moore-Algorithmus für die Textsuche

Einführung in den Boyer-Moore-Algorithmus für die Textsuche

Statistics

Views

Total Views
12,231
Views on SlideShare
12,145
Embed Views
86

Actions

Likes
0
Downloads
0
Comments
1

3 Embeds 86

http://www.slideshare.net 73
http://static.slidesharecdn.com 12
http://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1 previous next

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • I respectfully disagree with a couple of the ideas on AC Moore Arts & Crafts in Asheville North Carolina especially as it has to do with ac moore but will research this further externally on Friday to see how I feel about this.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Boyer-Moore-Algorithmus Boyer-Moore-Algorithmus Presentation Transcript

    • Boyer-Moore-Algorithmus Ein Textsuchalgorithmus fĂŒr große Alphabete Martin Szugat (Martin.Szugat@GMX.net)
    • Agenda
      • Evolution: Von der naiven Suche ĂŒber Knuth-Morris-Pratt zu Boyer-Moore
      • Schlechte Zeichen und gute Suffixe
      • Boyer-Moore vom Anfang bis zum Ende
      • Fazit: Der Durchschnitt siegt!
    • Problemstellung
      • Exakte Suche von
      • kurzen Zeichenfolgen in
      • langen Zeichenfolgen
    • Zur Erinnerung!!!
      • Das Muster (engl. Pattern) ist die gesuchte Zeichenfolge.
      • Der Text ist die durchsuchte Zeichenfolge.
      • Als ( Mis- ) Match wird die (Nicht-)Überein-stimmung von einem Zeichen aus dem Muster mit einem Zeichen im Text bezeichnet.
      • Nach einem Mismatch wird das Muster im Text verschoben, was als Shift bezeichnet wird.
    • Lösung I: Naive Suche
      • Vergleiche die Zeichen des Musters mit den Zeichen des Textes,
      • solange wie kein Mismatch auftritt.
      • Bei einem Mismatch verschiebe das Muster um ein Zeichen im Text und
      • beginne von vorne.
      • Falls alle Zeichen ĂŒbereinstimmen, wurde ein Treffer erzielt.
    • Naive Suche - Beispiel
      • Text aaaabaaaac...
      • Muster aaaac
      Anzahl der Vergleiche: 0
    • Naive Suche - Beispiel
      • Text a aaabaaaac...
      • Muster a aaac
      Anzahl der Vergleiche: 1
    • Naive Suche - Beispiel
      • Text a a aabaaaac...
      • Muster a a aac
      Anzahl der Vergleiche: 2
    • Naive Suche - Beispiel
      • Text aaaa b aaaac...
      • Muster aaaa c
      Anzahl der Vergleiche: 5
    • Naive Suche - Beispiel
      • Text aaaa b aaaac...
      • Muster aaaa c
      Anzahl der Vergleiche: 5
    • Naive Suche - Beispiel
      • Text a aaa b aaaac...
      • Muster aaa a c
      Anzahl der Vergleiche: 9
    • Naive Suche - Beispiel
      • Text aa aa b aaaac...
      • Muster aa a ac
      Anzahl der Vergleiche: 12
    • Naive Suche - Beispiel
      • Text aaaab aaaac ...
      • Muster aaaac
      Anzahl der Vergleiche: 20
    • Naive Suche - Laufzeit
      • Um in einem Text der LĂ€nge n
      • ein Muster der LĂ€nge m zu finden,
      • benötigt die naive Suche maximal
      • m (n – m + 1)
      • Vergleiche.
    • Lösung II: Knuth-Morris-Pratt
      • Idee: GrĂ¶ĂŸere Shifts durch Wiederholungen von Zeichenfolgen im Muster.
      • Algorithmus:
      • Berechne die LĂ€nge der eigentlichen RĂ€nder aller PrĂ€fixe des Musters.
      • Vergleiche das Muster mit dem Text.
      • Bei einem Mismatch verwende die RĂ€nderlĂ€ngen, um das Muster im Text zu verschieben.
    • LĂ€nge der RĂ€nder aller PrĂ€fixe
      • Muster Δ a b a b c
      • RandlĂ€nge
      Leeres Wort
    • LĂ€nge der RĂ€nder aller PrĂ€fixe
      • Muster Δ a b a b c
      • RandlĂ€nge -1
      Per Definition Leeres Wort
    • LĂ€nge der eigentlichen RĂ€nder aller PrĂ€fixe
      • Muster Δ a b a b c
      • RandlĂ€nge -1 0 0
    • LĂ€nge der RĂ€nder aller PrĂ€fixe
      • Muster Δ a b a b c
      • RandlĂ€nge -1 0 0 1
    • LĂ€nge der RĂ€nder aller PrĂ€fixe
      • Muster Δ a b a b c
      • RandlĂ€nge -1 0 0 1 2
    • LĂ€nge der RĂ€nder aller PrĂ€fixe
      • Muster Δ a b a b c
      • RandlĂ€nge -1 0 0 1 2 0
    • Knuth-Morris-Pratt - Beispiel
      • Text a b a b a b c ...
      • Muster a b a b c
    • Knuth-Morris-Pratt - Beispiel
      • Text a b a b a b c ...
      • Muster a b a b c
      • Position 0 1 2 3 4
      • - RandlĂ€nge -1 0 0 1 2 0
      • = Shift 2
      Anzahl der Vergleiche: 5
    • Knuth-Morris-Pratt - Beispiel
      • Text a b a b a b c ...
      • Muster a b a b c
      Anzahl der Vergleiche: 5
    • Knuth-Morris-Pratt - Beispiel
      • Text a b a b a b c ...
      • Muster a b a b c
      Anzahl der Vergleiche: 6
    • Knuth-Morris-Pratt - Beispiel
      • Text a b a b a b c ...
      • Muster a b a b c
      Anzahl der Vergleiche: 8
    • Knuth-Morris-Pratt - Laufzeit
      • FĂŒr die eigentliche Suche:
      • 2n – m + 1
      • FĂŒr die Tabelle mit den LĂ€ngen der RĂ€nder:
      • 2m - 1
      • FĂŒr den KMP-Algorithmus insgesamt:
      • 2n + m
    • Knuth-Morris-Pratt - Worst-Case
      • Text a a c a a c a a b
      • Muster a a b
      • Position 0 1 2
      • – RandlĂ€nge -1 0 1 0
      • = Shift 1
      Anzahl der Vergleiche: 3
    • Knuth-Morris-Pratt - Worst-Case
      • Text a a c a a c a a b
      • Muster a a b
      • Position 0 1 2
      • – RandlĂ€nge -1 0 1 0
      • = Shift 1
      Anzahl der Vergleiche: 5
    • Knuth-Morris-Pratt - Worst-Case
      • Text a a c a a c a a b
      • Muster a a b
      • Position 0 1 2
      • – RandlĂ€nge -1 0 1 0
      • = Shift 1
      Anzahl der Vergleiche: 6
    • Knuth-Morris-Pratt - Worst-Case
      • Text a a c a a c a a b
      • Muster a a b
      • Position 0 1 2
      • – RandlĂ€nge -1 0 1 0
      • = Shift 1
      Anzahl der Vergleiche: 9
    • Knuth-Morris-Pratt - Worst-Case
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 14
    • Bad Character
      • Definition: Ein Zeichen, welches einen Mismatch auslöst, wird Bad Character genannt.
      • Problem: Das Bad Character wird beim Shift nicht berĂŒcksichtigt
      • Folge: Das Muster wird im schlechtesten Fall stets nur um ein Zeichen verschoben.
      • Sonderfall: Das Bad Character taucht im Muster ĂŒberhaupt nicht auf.
      • Lösung: Falls das Bad Character nicht im Muster vorkommt, verschiebe das Muster um die volle LĂ€nge.
    • Bad Character – Beispiel I
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 3
    • Bad Character - Beispiel I
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 6
    • Bad Character - Beispiel I
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 9
    • Muster von rechts nach links vergleichen
      • Problem: Es mĂŒssen weiterhin alle Zeichen im Text mindestens einmal mit einem Zeichen aus dem Muster verglichen werden.
      • Lösung: Vergleiche das Muster von rechts nach links mit dem Text.
      • Vorteil: Bad Character werden schneller erkannt!
    • Bad Character - Beispiel II
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 1
    • Bad Character - Beispiel II
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 2
    • Bad Character - Beispiel II
      • Text a a c a a c a a b
      • Muster a a b
      Anzahl der Vergleiche: 5
    • Bad Character-Regel
      • Sei A das verwendete Alphabet,
      • und c ein Zeichen aus dem Alphabet A ,
      • dann liefert die Funktion s(c)
        • die Position des letzten Auftretens von c im Muster
        • den Wert -1 , falls c nicht im Muster auftaucht.
      • FĂŒr einen Mismatch an Position j gilt:
      • Shift = j – s(c) , sofern s(c) < j
    • Bad Character-Regel - Laufzeit
      • Im Best-Case hat der Boyer-Moore-Algorithmus dank der Bad Character-Regel eine Laufzeit von
      • n / m
      • Im Worst-Case hat er mit der Bad Character-Regel alleine jedoch eine Laufzeit von
      • n · m
    • Sprungtabelle
      • Der Boyer-Moore-Algorithmus benötigt zusĂ€tzlich eine Sprungtabelle,
      • um auch im Worst-Case eine Laufzeit linear zu n zu erreichen.
      • Vorgehen:
      • Berechne die LĂ€ngen der Teilzeichenfolgen des Musters, die auch Suffixe des Musters sind.  Good Suffix
      • Berechne die Sprungtabelle.
    • Good Suffix - Beispiel
      • Text: Wiederholung von
      • baabaabaaaabaabaabaaaabaabaabaaaa...
      • baabaabaaba
      • Muster
      Anzahl der Vergleiche: 0
    • Good Suffix - Beispiel
      • Text: Wiederholung von
      • baabaabaa a a baabaabaaaabaabaabaaaa...
      • baabaabaa b a
      • Muster
      Anzahl der Vergleiche: 2
    • Good Suffix - Beispiel
      • Text: Wiederholung von
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • baabaa b aaba
      • Muster
      Anzahl der Vergleiche: 7 Shift um 2
    • Good Suffix - Beispiel
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • baabaa b aaba
      Anzahl der Vergleiche: 7 Weak Good Suffix!
    • Good Suffix - Beispiel
      • baabaaba a aabaaba abaaaabaabaabaaaa...
      • baa b aabaaba
      Anzahl der Vergleiche: 15 Mismatch an derselben Stelle im Text mit dem gleichen Zeichen im Muster! Shift um 3
    • Strong Good Suffix-Regel
      • Problem: Mit einer Weak Good Suffix-Regel hat der Boyer-Moore-Algorithmus in diesem Fall eine Laufzeit von (n · m) / 6
      • Lösung: Strong Good Suffix-Regel
      • Vorteil: An der Stelle, an der ein Mismatch erfolgte, befindet sich nach einem Shift ein anderes Zeichen als jenes, welches den Mismatch verursachte.
    • Strong Good Suffix - Beispiel
      • Text: Wiederholung von
      • baabaabaa a a baabaabaaaabaabaabaaaa...
      • aaabaabaa b a
      • Muster
      Anzahl der Vergleiche: 2
    • Strong Good Suffix - Beispiel
      • Text: Wiederholung von
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • aaabaa b aaba
      • Muster
      Anzahl der Vergleiche: 7 Shift um 2
    • Strong Good Suffix - Beispiel
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • aaabaa b aaba
      Anzahl der Vergleiche: 7 Weak Good Suffix
    • Strong Good Suffix - Beispiel
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • aaabaa b aaba
      Anzahl der Vergleiche: 7 Strong Good Suffix!
    • Strong Good Suffix - Beispiel
      • baabaaba a aaba abaaba aaabaabaabaaaa...
      • a aaba abaaba
      Anzahl der Vergleiche: 18 Shift um 6 Bereits ĂŒberprĂŒfter Bereich wird erneut verglichen.
    • Kein Strong Good Suffix?!
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • baabaa b aaba
      Anzahl der Vergleiche: 7 Weak Good Suffix
    • Regel fĂŒr die RĂ€nder
      • Problem: Die ĂŒbereinstimmende Zeichenfolge kommt kein zweites Mal (als Strong Good Suffix ) im Muster vor.
      • Folge: Die Sprungtabelle liefert fĂŒr diesen Fall einen Shift von 0!
      • Lösung: Eine 2. Sprungtabelle wird berechnet, welche die eigentlichen RĂ€nder des Musters berĂŒcksichtigt.
    • Randregel - Beispiel
      • baabaaba a aaba abaabaaaabaabaabaaaa...
      • baabaa b aaba
      Anzahl der Vergleiche: 7 In einer 2. Sprungtabelle werden die eigentlichen RĂ€nder des Musters berĂŒcksichtigt.
    • Randregel - Beispiel
      • baabaabaaaa ba abaabaa a a baabaabaaaa...
      • ba abaabaa b a
      • To be continued ...
      Anzahl der Vergleiche: 9 Vorheriger Mismatch
    • Boyer-Moore: Top-Down
      • Berechne die Tabelle fĂŒr die Bad Character-Regel und die Sprungtabelle (Strong Good Suffix und Randregel).
      • Vergleiche das Muster mit dem Text, solange bis ein Mismatch auftritt.
      • Bei einem Mismatch ermittle anhand der aktuellen Position den Sprungwert fĂŒr die Bad Character-Regel und fĂŒr die Sprungtabelle.
      • FĂŒhre den grĂ¶ĂŸeren der beiden Shifts durch.
    • Algorithmus fĂŒr die Bad Character-Regel
      • Erzeuge eine Tabelle mit der GrĂ¶ĂŸe des verwendeten Alphabets und initialisiere die Felder mit dem Wert -1 .
      • Durchlaufe das Muster von links nach rechts
      • und speichere die Position des aktuellen Zeichens in der Tabelle. Als Index verwende das Zeichen.
      • Beispiel „abcab“: &quot;a&quot;  3, &quot;b&quot;  4, &quot;c&quot;  2, &quot;d&quot;  -1, ...
    • Algorithmus fĂŒr die Sprungtabelle
      • Berechne eine Zwischentabelle mit den LĂ€ngen der Teilzeichenfolgen, die ein starkes Suffix des Musters sind.
      • Berechne anhand der Zwischentabelle die Sprungtabelle 1. fĂŒr die Strong Good Suffix-Regel und die Sprungtabelle 2. fĂŒr die Randregel.
      • Kombiniere beide Sprungtabellen.
    • Berechnung der Zwischentabelle
      • Index i 0 1 2 3 4 5 6 7 8
      • Muster P b a b a c b a b a
      • SuffixlĂ€nge N(i) 0 2 0 4 0 0 2 0 -
      N(i):= max{j: j ≄ 0 Λ P[(i – j + 1)..i] ist Suffix von P}
    • Berechnung der Zwischentabelle
      • Index i 6
      • Muster P b a b a c b a b a
      • SuffixlĂ€nge N(i) 2
      N( 6 ):= max{j: j ≄ 0 Λ P[( 6 – j + 1).. 6 ] ist Suffix von P} = 2
    • Algorithmus fĂŒr die Berechnung der Zwischentabelle (1)
      • Durchsuche das Muster von rechts nach links per Brute-Force nach einem Suffix des Musters.
      d c b a b a c b a i,e b a a N(i) = i – a Muster P
    • Algorithmus fĂŒr die Berechnung der Zwischentabelle (2)
      • Falls gilt: a < i < e
      • Wird N(i) mit N(|P| + i - e - 1) berechnet.
      • 1. Fall: N(|P| + i - e - 1) < i - a
      d c b a b a c b a b a i c b a b a N(i) = N(|P| + i – e - 1) N(3) = N(8) = 2 e a c b a b a
    • Algorithmus fĂŒr die Berechnung der Zwischentabelle (3)
      • 2. Fall: N(|P| + i - e - 1) >= i - a
      a b a b a c b a b a i b a b a N(i) >= N(|P| + i – e - 1) N(2) = N(7) + 1 = 2 + 1 = 3 e a b a b a
    • Berechnung der Sprungtabelle 1.
      • FĂŒr den Fall, dass
      • Gesucht Shift s minimal mit: N(|P| - s – 1) = |P| - j - 1
      Text Muster P Muster P Fehler bei i + j i s |P| - j - 1 s
    • Berechnung der Sprungtabelle 2.
      • FĂŒr den Fall, dass
      • Gesucht Shift s minimal mit: N(|P| - s – 1) = |P| - s
      Text Muster P Muster P Fehler bei i + j i s |P| - s
    • Laufzeiten bei Boyer-Moore I
      • FĂŒr die Berechnung der Bad Character-Regel:
        • AbhĂ€ngig von der GrĂ¶ĂŸe des Alphabets
        • Allerdings: Keine Zeichenfolgenvergleiche
        • Sondern: Nur Speicherzugriffe ĂŒber einen Index
      • FĂŒr die Berechnung der Sprungtabelle 1. und 2.:
        • Vergleichbar zum KMP
        • Laufzeit: linear
    • Laufzeiten bei Boyer-Moore II
      • FĂŒr die eigentliche Suche:
        • Unterscheidung zwischen initialen und wiederholten Vergleichen mit einem Zeichen im Muster
        • Laufzeit: linear
      • FĂŒr den Boyer-Moore-Algorithmus insgesamt:
        • Aufwendige Analyse
        • Maximal 3(n + m) Vergleiche notwendig
    • Fazit: Vorteile von Boyer-Moore
      • Bad Character-Regel
      •  Große Alphabete: Proteine
      • Muster von rechts nach links vergleichen
      •  Im Best-Case eine Laufzeit von n / m
      • Strong Good Suffix-Regel
      •  Im Worst-Case eine Laufzeit von 3 (n + m)
    • Vergleich zu Knuth-Morris-Pratt Um so grĂ¶ĂŸer das verwendete Alphabet ist und um so weniger Wiederholungen das Muster und der Text enthĂ€lt, um so stĂ€rker nĂ€hert sich die tatsĂ€chliche Laufzeit der Laufzeit im Best-Case an. 3 (n + m) 2 (n + m) Worst-Case n / m 2 (n + m) Best-Case Boyer-Moore Knuth-Morris-Pratt Algo Case
    • Noch Fragen???
      • May the source be with you ...