Algorithmus Boyer - Moore Bestimmung der last-Funktion

Algorithmus Boyer - Moore
(Suchen der Positionen aller Auftreten des Pattern)
Es gelte
last[a] = max{0} ∪ {k | p[k] = a, 1 ≤ k ≤ m} und
shift[i] = min {t | t ≥ 1 und (t ≥ i oder p[i − t] ≠ p[i])
und ((t ≥ k oder p[k − t] = p[k]) für i < k ≤ m)}
j := 0; /* Zeiger in den Eingabestring s[1..n] */
while j ≤ n-m do
begin
i := m; /* Zeiger in das Pattern p[1..m] */
while i > 0 and p[i] = s[j+i] do
i := i-1;
/* Vergleichen des Patterns mit dem Text */
/* von rechts nach links */
if i = 0 then
/* Pattern gefunden */
begin
print j+1;
j := j + shift[0];
end
else
/* Verschieben des Patterns nach rechts */
/* entsprechend der shift- und last-Funktion */
end
j := j + max(shift[i], i-last[s[j+i]]);
Bestimmung der last-Funktion
(Es sei eine entsprechende Kodierung der Symbole aus Σ vorausgesetzt)
for all c in Sigma do
last[c] := 0;
for i := 1 to m do
last[p[i]] := i;

Algorithmus zur Bestimmung der shift-Funktion (Boyer-Moore)
/* zunächst maximale Verschiebung annehmen */
for i := 0 to m do shift[i] := m;
/* Hilfsarray f mit f[j] = m-|Rand(p[j+1..m])| und */
/* f[m] = m+1 */
/* Berechnung der shift-Funktion für Situation 1 */
j := m;
k := m+1;
while j > 0 do
begin
f[j] := k; /* für j < m ist k = m-|Rand(p[j+1..m])| */
while k ≤ m and p[j] ≠ p[k] do
begin
shift[k] := min(shift[k], k-j);
k := f[k];
end;
j := j-1;
k := k-1;
end;
/* an dieser Stelle ist k = m-|Rand(p)| */
/* Ende der Phase 1 */
/* Berechnung der shift-Funktion für Situation 2 */
for i := 0 to k do shift[i] := min(shift[i], k);
/* Ende der Phase 2 */
/* Berechnung der shift-Funktion falls der Fehler */
/* im Suffix Rand(p) auftritt */
j := k
k := f[k];
while j ≤ m do
begin
while j ≤ k do
begin
shift[j] := min(shift[j], k);
j := j+1;
end;
k := f[k];
end;
/* Ende Phase 3 */

Beispiel für das Boyer-Moore Verfahren
Es ist i 0 1 2 3 4 5 6 7 8
p[i] G C A G A G A G
shift[i] 7 7 7 7 2 7 4 7 1
und
c A C G T
last[c] 7 2 8 0
1: G C A G A G A G
#
G C A T C G C A G A G A G T A T A C A G T A C G
shift[8] = 1, 8-last[A] = 1, also nächster Versuch bei j = 1
2: G C A G A G A G
# | |
G C A T C G C A G A G A G T A T A C A G T A C G
shift[6] = 4, i-last[C] = 4, also nächster Versuch bei j = 5
3: G C A G A G A G
| | | | | | | |
G C A T C G C A G A G A G T A T A C A G T A C G
shift[0] = 7, also nächster Versuch bei j = 12
4: G C A G A G A G
# | |
G C A T C G C A G A G A G T A T A C A G T A C G
shift[6] = 4, i-last[C] = 4, also nächster Versuch bei j = 16
5: G C A G A G A G
# |
G C A T C G C A G A G A G T A T A C A G T A C G
shift[7] = 7, i-last[C] = 5, also nächster Versuch bei j = 23