String-Matching-Algorithmus

Eine gesichtete Version dieser Seite, die am 23. Oktober 2013 freigegeben wurde, basiert auf dieser Version.

In der Informatik sind String-Matching-Algorithmen eine Gruppe von Algorithmen, die das Finden von Textsegmenten in einer Zeichenkette (engl. string) anhand eines vorgegebenen Suchmusters beschreiben. Sie zählen somit zur Klasse der Zeichenkettenalgorithmen.

Im engeren Sinne suchen diese Algorithmen nach exakten Übereinstimmungen (engl. matches). Im weiteren Sinne sind auch Algorithmen gemeint, die ungefähre Übereinstimmungen zulassen, wobei der Begriff ungefähr durch ein Toleranzkriterium genau definiert sein muss.

Das Problem besteht darin, diese Aufgabe möglichst effizient zu lösen. In der Praxis ist dies bedeutsam, wenn in großen Textmengen (wie z. B. Wikipedia) Suchbegriffe gefunden werden sollen.

Exakte Suche

Problemstellung

Grundsätzlich sind zwei Situationen zu unterscheiden:

Nach Vorgabe einer Suchmaske sollen beliebige Texte durchsucht werden.
Der Text ist vorgegeben, und dann sollen beliebige Suchmasken im Text gefunden werden.

Der zweite Fall entspricht etwa der Aufgabe, die Wikipedia derart aufzubereiten, dass beliebige Suchmasken schnell und effizient aufgefunden werden. Auch Suchmaschinen im Internet finden sich in der zweiten Situation.

Im Folgenden wird jedoch nur auf die erste Situation eingegangen.

Lösungsmethoden

Naiver Algorithmus

Der einfachste Algorithmus besteht darin, ein so genanntes Suchfenster von der Länge der Suchmaske über den Text zu schieben. In jeder Position der Suchmaske werden die Symbole der Maske mit denen des darunterliegenden Textes verglichen. Wenn ein nichtübereinstimmendes Symbol gefunden wird, wird das Fenster um eine Position verschoben, und erneut ein Vergleich angestellt; wenn alle Symbole im Fenster übereinstimmen, ist die Suchmaske gefunden worden. Der Algorithmus endet, wenn der ganze Text vom Fenster abgesucht worden ist.

Dieser Algorithmus hat eine Laufzeit von der Ordnung O=n·m, wenn m die Länge der Suchmaske und n die Länge des Textes ist.

Pseudocode:

Eingabe: Strings T = T₁… T_n und P = P₁ … P_m
Ausgabe: q die Stellen an denen P in T auftritt

For q = 0 to n − m do
    If P₁ = T_q+1 and P₂ = T_q+2 and … and P_m = T_q+m:
    Print q

Überraschenderweise ist der naive Ansatz in der Praxis sehr schnell, da Fehler in natürlichsprachigen Texten nach 1 bis 2 Zeichen auftauchen. Für die englische Sprache ergibt sich eine Wahrscheinlichkeit von 1.07 Zeichen. Somit ist der naive Ansatz nahezu linear schnell.

Dies wird auch deutlich wenn man sich den ungünstigsten Fall selbst ansieht. Er lautet

Text:   aaa...aab
Muster: ab

Derartige Fälle sind in natürlich sprachlichen Texten äußerst unwahrscheinlich.

Endlicher Automat

Bei dem String-Matching-Algorithmus mit Hilfe von endlichen Automaten wird ein Automat mit $q_{i}$ Zuständen, mit $0<=i<=m$ mit $m$ als Länge des Patterns, erstellt. Dabei stellt $i$ die Anzahl von übereinstimmenden Buchstaben im Pattern vom String-Anfang an betrachtet dar. Zur Einfachheit sei $P_{i}$ der Prefix vom Pattern bis zum Buchstaben an der Stelle $0<=i<=m-1$ . Die Übergangsfunktion $delta(q_{i},a)$ gibt nun wieder einen Zustand $q_{j}$ zurück, bei dem $j$ die maximale Anzahl von Buchstaben darstellt, mit der $P_{j}$ ein Prefix vom Wort $P_{i}a$ ist. Also $delta(q_{i},a)=q_{max\{j:P_{j}{\text{ ist Prefix von }}P_{i}a\}}$ .

Python-Implementation

def is_suffix(suffix, word):
    '''Überprüft ob der suffix ein Suffix von word ist.'''

    return word.endswith(suffix)

def transition(pattern, state, event):
    '''Hier wird die Übergangsfunktion berechnet.'''

    for k in range(state + 1, 0, -1):
        if is_suffix(pattern[:k], pattern[:state] + event):
            return k
    return 0

def create_matcher(alphabet, pattern):
    '''Erzeugt alle Zustände und eine Übergangsfunktions-Tabelle'''

    transition_table = {}
    for state in range(0, len(pattern) + 1):
       for event in alphabet:
            transition_table[(state, event)] = \
                transition(pattern, state, event)
    return transition_table, len(pattern)

def match(matcher, text):
    '''Gibt die gefundenen Treffer im Text mit dem Automaten der aus create_matcher
    erstellt wurde.'''

    transition_table, last_state = matcher
    matches = []
    state = 0
    text_pos = 0
    for text_pos in range(0, len(text)):
        state = transition_table[(state, text[text_pos])]
        if state == last_state:
            matches.append(text_pos - last_state + 1)
    return matches

def find(alphabet, pattern, text):
    matcher = create_matcher(alphabet, pattern)
    return match(matcher, text)

Der Knuth-Morris-Pratt-Algorithmus

Der Knuth-Morris-Pratt-Algorithmus baut auf dem naiven Suchalgorithmus auf. Wesentlicher Unterschied ist, dass das Vergleichsfenster nicht immer um nur eine Position weitergerückt wird, sondern eventuell um mehr als eine Position.

Dazu muss zu Anfang die Suchmaske analysiert werden, so dass bei jeder teilweisen Übereinstimmung, etwa der ersten k Symbole, bekannt ist, ob der Anfang der Suchmaske mit dem Ende der letzten übereinstimmenden Teilmaske übereinstimmt. Die Verschiebung der Suchmaske erfolgt nach der überlappenden Übereinstimmung; zusätzlicher Vorteil ist, dass die schon verglichenen Symbole nicht noch einmal verglichen werden müssen.

Suche im Suffixbaum

Insbesondere wenn der zu durchsuchende Text im Voraus bekannt ist, und in diesem später nach vielen unterschiedlichen Mustern gesucht werden soll, bietet sich die Konstruktion eines Suffixbaums an. Diese Konstruktion kann in O(n) erfolgen. Anschließend kann jedes Muster ohne erneute Vorbereitung des Texts in O(m) gesucht werden: Sofern es vorhanden ist, kann man von der Quelle des Suffixbaums den entsprechenden Knoten erreichen, ansonsten schlägt die Suche fehl (es ist kein entsprechender Knoten vorhanden).^[1]

Übersicht

	Vorbereitungszeit	Suchzeit
Naiver Algorithmus	0 (keine)	Θ((n-m+1)m)
Rabin-Karp-Algorithmus	Θ(m)	average Θ(n+m), worst Θ(n·m)
Endlicher Automat	O(m \|Σ\|)	Θ(n)
Knuth-Morris-Pratt-Algorithmus	Θ(m)	Θ(n)
Boyer-Moore-Algorithmus^[2]	Θ(m)	average Θ(n/m), worst Θ(nm)
Shift-Or-Algorithmus (Bitap Algorithmus, Baeza-Yates-Gonnet)	Θ(m+\|Σ\|)	Θ(n)
Suche im Suffixbaum	Θ(n)	Θ(m)

Wobei m die Länge der Suchmaske und n die Länge des Textes ist.

Weitere Algorithmen

Boyer-Moore-Algorithmus:
Skip-Search-Algorithmus
Baeza-Yates-Gonnet-Algorithmus („shift-or“)
Soundex
Kölner Phonetik

Mustervergleichssuche

Die Suche nach Mustern ist zwischen unscharfer und exakter Suche anzusiedeln, da der Benutzer explizit angeben muss, welchen Spielraum er für bestimmte Zeichenklassen an bestimmten String-Positionen zulässt.

Unscharfe Suche

Bei der unscharfen Suche entscheidet üblicherweise der Algorithmus nach Vorgabe eines Güte- oder Abstandskriteriums, wie groß die Abweichung von Treffern gehen darf.

Siehe auch

Suchverfahren
Levenshtein-Distanz (approximative Suche)
Volltextrecherche

Weblinks

Java-Animationen, die die Funktionsweise so gut wie aller exakten Suchalgorithmen veranschaulichen
StringSearch – high-performance pattern matching algorithms in Java – Implementierungen vieler String-Matching-Algorithmen in Java (BNDM, Boyer-Moore-Horspool, Boyer-Moore-Horspool-Raita, Shift-Or)
einfache und ausführliche Erklärung des Boyer-Moore-Algorithmus
Shift-And- (Shift-Or-)Algorithmus

Einzelnachweise

↑ Dan Gusfield: Algorithms on Strings, Sequences and Trees. 1999 [1997], ISBN 0-521-58519-8, Kapitel 7.1.APL1.
↑ R. S. Boyer, J. S. Moore: A fast string searching algorithm. In: Communications of the ACM. 20. Jahrgang, 1977, S. 762–772, doi:10.1145/359842.359859.

[1] Dan Gusfield: Algorithms on Strings, Sequences and Trees. 1999 [1997], ISBN 0-521-58519-8, Kapitel 7.1.APL1.

[2] R. S. Boyer, J. S. Moore: A fast string searching algorithm. In: Communications of the ACM. 20. Jahrgang, 1977, S. 762–772, doi:10.1145/359842.359859.

[1]

[2]