Aus ProgrammingWiki

Autor: Yevgeniy Oliynyk

Allgemeines und Festlegungen

String matching befasst sich allgemein mit dem Finden eines Wortes in einem Text.
Beim Text handelt es sich um eine endliche Folge von Zeichen (bestehend aus dem Alphabet $\Sigma$ der Groß- und Kleinbuchstaben, Zahlen und Satzzeichen) und wird mit $t$ abgekürzt. Das Wort setzt sich ebenfalls aus denselben Zeichen zusammen und wird abgekürzt als $w$ dargestellt. Obwohl es aus mehreren Wörtern bestehen kann, wird es im Folgenden als "Wort" bezeichnet.
Sowohl der Text, als auch das Wort, weisen eine bestimmte Länge auf. Dies bezieht sich auf die Anzahl der Zeichen des Textes bzw. des Wortes. Beim Text wird die Länge mit $n$ (bzw. $|t|$) bezeichnet und beim Wort mit $m$ (bzw. $|w|$). Dabei gilt für jedes Text- und Wortpaar in den Beispielen der Seite folgende Vereinbarung: $m \leq n$.
Um nun festzustellen, ob sich ein Wort in einem Text befindet, müssen einzelne Zeichen verglichen werden. Deren Positionen werden folgedermaßen beschrieben:

• das $i$-te Zeichen von $t$ heißt $t[i]$, wobei $1\leq i \leq n$ gilt
• das $j$-te Zeichen von $w$ heißt $w[j]$, wobei $1\leq j \leq m$ gilt.

Somit ist eine präzise Positionsangabe möglich.
Der Standardtext für alle hier aufgeführten Beispiele lautet: Das ist das Haus vom Nikolaus mit n=29.

Ein naiver Algorithmus

Vorüberlegung

Um zu erfahren, ob sich das gesuchte Wort an einer beliebigen Stelle $t[pos]$ ($1 \leq pos \leq n-m+1$) im Text befindet, muss ein Vergleich zwischen den Zeichen an der Stelle $t[pos]$ und $w[1]$ unternommen werden. Falls diese übereinstimmen, so wird weiter verglichen. Im nächsten Schritt wären es dann die Zeichen der Positionen $t[pos+1]$ und $w[2]$. In der Art und Weise geht es weiter, bis entweder irgendwann 2 ungleiche Zeichen miteinander verglichen werden oder der Fall eintritt, dass auch die Zeichen an der Stelle $t[pos+m-1]$ und $w[m]$ überein stimmen. Das erstere bedeutet, dass das Wort nicht im Text an der gegebenen Position vorkommt. Das letztere hingegen würde eine Erfolgsmeldung nach sich ziehen.

Beispiele

Programmbeispiel

Bisher wird aber nur eine Stelle im Text betrachtet. Um aber festzustellen, ob sich das Wort nicht nur an einer bestimmten Stelle befindet, sondern ob es an einer beliebigen Position vorkommt, ist eine Schleife nötig. Dadurch geht man Zeichen für Zeichen den Text durch und Vergleicht diesen mit dem Wort. Da es eine naive Methode ist, kann man ganz genau sagen, wie viele Schleifendurchläufe nötig sind, nämlich $n-m+1$. Als Ergebnis einer solchen Funktion, würde man alle Vorkommen des Wortes im Text und dessen Position als Ergebnis zurückbekommen. Sollte sich das Wort nicht im Text befinden, so bekommt man eine dementsprechende Antwort.

Ein passender Algorithmus dazu könnte wie folgt aussehen:

void naiveSuche(String text, String wort){ int laengeText = text.length(); int laengeWort = wort.length(); int position = 0; int aktZeichen; boolean gefunden = false; while (position <= laengeText-laengeWort){ aktZeichen = 0; while (aktZeichen < laengeWort && wort.charAt(aktZeichen)==text.charAt(position+aktZeichen)) aktZeichen++; if (aktZeichen == laengeWort){ System.out.println("Wort an der Stelle " + (position+1) + " im Text gefunden."); gefunden=true; } position++; } if (gefunden == false) System.out.println("Keine Treffer bei der Suche."); }

naiveSuche("Das ist das Haus vom Nikolaus","aus");

ausführen

Laufzeitanalyse

Durch die Einfachheit des Algorithmus lässt sich eine Laufzeitanalyse wunderbar durchführen.

Im Best-Case würde offensichtlich so aussehen, dass bei jedem Schleifendurchgang nur eine Vergleichsoperation durchgeführt wird. Dies wäre der Fall, wenn $m=1$ ist oder wenn das Zeichen $w[1]$ nicht in $t$ vorkommt. Somit ist die Laufzeit $\mathcal{O}(n-m+1)$.

Im Worst-Case gibt es den Fall, dass bei jeder Stelle des Textes, alle Zeichen des Wortes mit dem jeweiligen Zeichen des Textes verglichen werden müssen. Ein Beispiel für so einen Fall wäre

Der Boyer-Moore-Horspool Algorithmus

Der BMH Algorithmus kann eine deutliche Effizienzsteigung gegenüber dem naiven Algorithmus aufweisen. Er wurde 1980 von Nigel Horspool veröffentlicht und stellt eine Vereinfachung des Boyer-Moore Algorithmus dar.

Idee

Im naiven Algorithmus hat man immer bei einer bestimmten Position im Text das Wort mit dem Textabschnitt von links aus verglichen. Im Grunde ist es aber egal, ob man von links oder von rechts mit dem Vergleichen beginnt, denn das spielt in dem Fall keine Rolle. Für BMH jedoch ist es essenziell, dass man von rechts aus mit dem Vergleich beginnt. Dies bringt denn folgenden Vorteil mit sich, dass man eine Art Vorhersage treffen kann. Denn das Ziel dieses Verfahrens ist es, nicht jedes Zeichen des Textes zu untersuchen und somit unnötige Operationen einzusparen, ohne dabei das Risiko einzugehen, dass man ein Vorkommen des Wortes im Text übersieht. Dies gelingt mit diesem Vorhersehen und durch eine vorherige Auswertung des Wortes. Dadurch wird es möglich bis zu $m$ Stellen in Folge im Text auszulassen.

Beispiele

Bad-Character

Bevor man mit dem Suchen des Wortes im Text beginnt, erstellt man eine Tabelle $D$ mit allen möglichen Zeichen, die im Wort vorkommen dürfen ($\Sigma$). Jedem Zeichen wird ein bestimmter Wert zugeordnet, der später entscheidet, um wie viele Stellen das Wort verschoben werden darf. Dabei wird sinnvollerweise als erstes jedem Zeichen der Wert $m$ zugewiesen. Danach geht man Zeichenweise von links nach rechts das Wort durch und trägt in die entsprechenden Felder den Abstand zum rechten Ende des Wortes ein. Das letzte Zeichen, also $w[m]$, darf nicht mitberücksichtigt werden, da sonst $a=0$ wäre und $D[w[m]]=0$ verboten ist. Andernfalls würde der Algorithmus in einer Endlosschleife enden.

Beispiele für einige Tabellen $D$

Programmbeispiel

void bmh(String t, String w){ int n = t.length(); int m = w.length(); int[] d = badCharacter(w,m); int pos = 0; int j; boolean g = false; while (pos <= n-m+1){ j = m; while (j > 0 && w.charAt(j-1) == t.charAt(pos+j-2)) j--; if (j == 0){ System.out.println("Wort an der Stelle " + (pos) + " im Text gefunden."); g = true; } pos += d[(int)t.charAt(pos+m-2)]; } if (g == false) System.out.println("Keine Treffer bei der Suche."); } int[] badCharacter(String w, int m){ int[] d = new int[256]; for (int i = 0;i<256;i++) d[i] = m; char c; for (int i = 0;i<m-1;i++){ c = w.charAt(i); d[(int)c] = (i-m)*-1-1; } return d; }

bmh("Das ist das Haus vom Nikolaus","laus");

ausführen

Laufzeitanalyse

Obwohl auch hier im Worst-Case der Algorithmus dieselben Probleme aufweist wie der naive Algorithmus, ist dieser Algorithmus im Mittel jedoch viel schneller bei der Abarbeitung. Vor allem, wenn es sich um einen gewöhnlichen Text handelt. Dies kann sehr gut dadurch veranschaulicht werden, dass bei dem Algorithmus die Möglichkeit besteht, unnötiges Suchen an Stellen, wo niemals das Wort vorkommen kann, zu vermeiden. Doch um diesen Vorteil ausnutzen zu können, muss davor $D$ berechnet werden. Der Aufwand liegt dabei in $\mathcal{O}(m)$. Nach dieser einmaligen Vorverarbeitung arbeitet der eigentliche Suchalgorithmus in $\mathcal{O}(n)$ (im Average-Case) und ist somit potenziell deutlich schneller als das naive Verfahren.

Weitere Algorithmen

String-Matching mit endlichen Automaten

Es gibt viele Wortsuchalgorithmen, die mit Hilfe von endlichen Automaten arbeiten. Eins davon wird hier vorgestellt.
Die Motivation dahinter ist die Effizienz eines solchen Algorithmus. Bei der Suche nach einem Wort (in dem Zusammenhang auch Muster bzw. pattern genannt) wird jedes Textzeichen nur ein einziges Mal untersucht. Diese Untersuchung benötigt, anders als bei den vorherigen Verfahren, stets eine konstante Zeit. Somit schafft es der Algorithmus einen Aufwand zu erreichen, der in $\Theta(n)$ liegt, wenn man nur die Matchingzeit betrachtet.

Für die Veranschaulichung wird ein DEA mit $M = (Q,\Sigma , q_0 , E, \delta )$ verwendet. Dabei ist das Eingabealphabet $\Sigma$ nichts weiter als das am Anfang unter Allgemeines und Festlegungen festgelegte Alphabet und besteht demzufolge aus denselben Elementen. Da das Wort entscheidend für die Gestaltung des Automaten ist und nicht der Text, besitzt der Automat $m+1$ Zustände: $Q = \{ 0,1,2,...,m-1,m\} $, wobei $q_0 = 0$ ist. Es gibt nur einen Endzustand, nämlich $E = \{ m\} $. Diesen gilt es zu erreichen, damit $M$ das Signal geben kann, dass das Wort im Eingabetext des Automaten gefunden wurde. Jetzt fehlt nur noch die Übergangsfunktion $\delta$, die ein Wort im Text erkennen soll. Um diese Übergangsfunktion aufzustellen, gibt es eine Vorschrift.

Vorschrift

Compute-Transition-Function($w$,$\Sigma$)

1 $m ← länge[w]$
2 for $q ← 0$ to $m$
3   do for jedes Zeichen $a \in \Sigma $
4     do $k ←$ min$(m+1,q+2)$ 
5       repeate $k ← k - 1$
6         until $w_k \sqsupset w_q a$
7       $\delta (q,a) ← k$
8 return $\delta $

DEA für $w = ababaca$

Beispiel

$M = (Q,\Sigma , q_0 , E, \delta )$, mit

• $Q = \{ 0,1,2,3,4,5,6,7\} $
• $\Sigma = \{ a,b,c\} $
• $q_0 = 0$
• $E = \{ 7\} $
• $\delta$

Der Knuth-Morris-Pratt-Algorithmus

Obwohl die Suche beim endlichen Automaten eine akzeptable Laufzeit ausweist, stellt die Vorverarbeitung und damit die Berechnung der Überführungsfunktion mit einem Aufwand in $\Theta(m |\Sigma|)$ ein Hindernis dar. Eine vielversprechende Lösung bietet der KMP Algorithmus. Statt der $\delta$ kommt eine Hilfsfunktion $\pi$ (auch Feld genannt) zum Einsatz für die Vorberechnung. Deren Aufwand liegt in nur $\Theta(m)$. Das Matching selber ist vom Aufwand her derselbe, wie schon mit endlichen Automaten.

KMP-Matching-Algorithmus

KMP-Matcher($t$,$w$)

 1  $n ← länge[t]$
 2  $m ← länge[w]$
 3  $\pi ←$Compute-Prefix-Function($w$)
 4  $q ← 0$
 5  for $i ← 1$ to $n$
 6      do while $q > 0$ und $w[q+1] ≠ t[i]$
 7          do $q ← \pi[q]$
 8        if $w[q+1] = t[i]$
 9          then $q ← q+1$
10        if $q=m$
11          then print "Das Wort tritt mit der Verschiebung" $i-m$ "auf"
12            $q ← \pi[q]$

Compute-Prefix-Function($w$)

 1  $m ← länge[w]$
 2  $\pi[1] ← 0$
 3  $k ← 0$
 4  for $q ← 2$ to $m$
 5      do while $k>0$ und $w[k+1] ≠ w[q]$
 6          do $k ← \pi[k]$
 7        if $w[k+1] = w[q]$
 8          then $k ← k+1$
 9        $\pi[q] ← k$
10  return $\pi$

Das Ziel der Präfixfunktion ist es, für jedes Zeichen von $w$ einen Wert $\pi$ zu berechnen, der beim Matching aussagt, was die nächste Position ist, auf die das Wort verschoben werden soll. Die Demonstration geschieht an einem Beispiel.

Zuerst wird die Tabelle $\pi$ für das Wort $w=ababababca$ berechnet.

Jeder Wert $\pi[i]$ gibt darüber Auskunft, um wie viele Stellen das Wort beim Suchen verschoben werden kann für den Fall, dass $w[i+1]$ nicht mit $t[j]$ (wobei $0<j<n$) übereinstimmt oder $w[m] = w[j]$ ist. Dabei berechnet sich die Verschiebung aus $i-\pi[i]$. Die Funktion gibt außerdem eine Auskunft über die Präfixeigenschaften des Wortes (wodurch sie auch zustande kommt). So ist $w_{\pi[i]}$ ein Präfix von $w_i$.

Beispiel

Für die Suche des Wortes $w$ im Text $t=abababababcbababababca$ sehen die entscheidenden Schritte folgendermaßen aus:

Überblick aller Laufzeiten

Lösungen

Aufgabe 1

void bmh(String text, String wort){ int laengeText = text.length(); int laengeWort = wort.length(); int position = 0; int aktZeichen; int zaehlerStellen=0; boolean gefunden = false; while (position <= laengeText-laengeWort){ aktZeichen = 0; zaehlerStellen++; while (aktZeichen < laengeWort && wort.charAt(aktZeichen)==text.charAt(position+aktZeichen)){ aktZeichen++; } if (aktZeichen == laengeWort){ System.out.println("Wort an der Stelle " + (position+1) + " im Text gefunden."); gefunden=true; } position++; } if (gefunden == false) System.out.println("Keine Treffer bei der Suche."); System.out.println(zaehlerStellen + " Stellen wurden durchsucht."); }

Aufgabe 2

void bmh(String t, String w){ int n = t.length(); int m = w.length(); int[] d = badCharacter(w,m); int pos = 0; int j; int zS=0; boolean g = false; while (pos <= n-m+1){ zS++; j = m; while (j > 0 && w.charAt(j-1) == t.charAt(pos+j-2)) j--; if (j == 0){ System.out.println("Wort an der Stelle " + (pos) + " im Text gefunden."); g = true; } pos += d[(int)t.charAt(pos+m-2)]; } if (g == false) System.out.println("Keine Treffer bei der Suche."); System.out.println(zS + " Stellen wurden durchsucht."); } int[] badCharacter(String w, int m){ int[] d = new int[256]; for (int i = 0;i<256;i++) d[i] = m; char c; for (int i = 0;i<m-1;i++){ c = w.charAt(i); d[(int)c] = (i-m)*-1-1; } return d; }

Aufgabe 3

Übergangsfunktion in Form einer Tabelle:

Analyse: ein DEA akzeptiert nur vollständig gelesene Wörter und nur dann, wenn der Zustand nach dem vollständigen Lesen ein Endzustand ist. Somit ist er nicht in der Lage mehrere Vorkommen eines Wortes in einem Text zu finden bzw. nur wenn das Wort an der Stelle $n-m+1$ im Text steht.
Änderung: DEA in NEA umwandeln und die Übergänge für alle $\Sigma$ von $q_m$ nach $q_m$ ergänzen.

Aufgabe 4

Quellen

• Cormen, Thomas; Leiserson, Charles; Rivest, Ronald; Stein, Clifford: Algorithmen, eine Einführung,Oldenbourg Verlag, 2007
• Vöcking, Berthold: Taschenbuch der Algorithmen, Springer-Verlag, 2008