Zeichenketten. Hauptseminar Hallo Welt! für Fortgeschrittene. SS Mai 2006 Tobias Hager.

Transkript

1 Zeichenketten Hauptseminar Hallo Welt! für Fortgeschrittene SS Mai 2006 Friedrich-Alexander Universität Erlangen-Nürnberg

2 Gliederung 2 1. Motivation 2. Allgemeines zu Zeichenketten 3. String Matching - Naiver Algorithmus - Algorithmus von Knuth-Morris-Pratt - Boyer-Moore Algorithmus - Rabin-Karp Algorithmus 4. Tries - Suffix- - PATRICIA- 5. Zusammenfassung und Ausblick

3 Motivation 3 Suchen von Mustern gehört zu den grundlegenden Problemen der Informatik! Sicherer Umgang mit Zeichenketten ist auch von entscheidender Bedeutung für die erfolgreiche Teilnahme am ICPC! Beispiele: Internetsuchmaschinen durchsuchen eine riesige Menge von Zeichenketten: Gemeldete Domains 2005 in Deutschland ~ 8.8 Mio Suche von Mustern in einer DNA Sequenz: (menschliches Genom) 3 Milliarden Basenpaare! ~ Gene Durchschnittliche Genlänge: Basenpaare effiziente Algorithmen notwendig

4 Allgemeines zu Zeichenketten ASCII 4 ASCII = Amercian Standard Code for Information Interchange Darstellung durch 1 Byte, wobei erstes Bit immer auf 0 gesetzt ist Somit sind 2 7 = 128 Zeichen darstellbar Nicht druckbar sind die Zeichen 0 bis 31 und 127 Uneinheitliche Verwendung von \n (newline) und \r (carriage-return) Zeichentabelle abrufbar mit man ascii

5 Allgemeines zu Zeichenketten ASCII-Tabelle 5

6 Allgemeines zu Zeichenketten UNICODE & ISO Zeichen sind viel zu wenig Erweiterung nötig Anfangs viele verschiedene Standards Mittlerweile Unicode und ISO als Standard Vor dem Verarbeiten von elektronischen Texten muss der Zeichensatz eingestellt werden: - HTML: <meta http-equiv="content-type" content="text/html; charset=utf-8"> - Content-Type: text/plain;charset="iso "

7 Allgemeines zu Zeichenketten UNICODE für C/C++ 7 wide character type: wchar_t (2 Byte groß) In der Header-Datei whar.h sind die Funktionen zum Bearbeiten des Datentyps definiert Die alphabetische Sortierung ist bei Unicode aufwändiger als bei ASCII, da bei ASCII die Buchstaben und Ziffern sequentiell angeordnet sind und so schnell sortiert werden kann Beispiel: char string[] = "Hallo"; wchar_t wstring[] = L"Hallo"; Das L vor Zeichenkette sagt dem Compiler, dass es sich um eine Zeichenkette mit 2-Byte Elementen handelt Für weitere Infos siehe:

8 Allgemeines zu Zeichenketten UNICODE Java 8 In Java ist der Datentyp char 16 Bit groß Damit können von vornherein schon mehr Zeichen dargstellt werden Unicode ist darin bereits enthalten Ein spezielles Unicode-Zeichen kann mit \u0000 bis \uffff in einen String eingefügt werden ABER: Unicode 4.0 definiert wesentlich mehr als Zeichen Lösung: Supplementary Characters, die mit neuen Funktionen und Methoden auf vorzeichenbehafteteten 32 Bit Integer-Werten arbeiten

9 Allgemeines zu Zeichenketten Repräsentation im Rechner 9 1.) NULL-terminiertes Feld Zeichen werden sequentiell in einem Feld gespeichert, durch den NULL-Character \0 wird das Ende markiert Verwendung in C / C++ 2.) Feld plus Länge Java: Länge der Zeichenkette wird am Anfang des Feldes gespeichert Feld in Java natürlich nur intern, nach außen hin String-Objekt 3.) Verkettete Liste je Zeichen muss auch noch ein Zeiger auf das nächste Zeichen mit gespeichert werden

10 Allgemeines zu Zeichenketten Operationen (1) 10 Speicherbedarf Ermitteln der Stringlänge 1.) (Stringlänge + 1) * Zeichengröße 1.) O(n) (Bis zum NULL-Character durchzählen) 2.) (Stringlänge + 1) * Zeichengröße 2.) O(1) (Länge steht am Anfang des Feldes) 3.) (Zeichengröße + Zeigergröße) * Stringlänge 3.) O(n) (Bis zum NULL-Character durchzählen) 1.) Feld + \0 2.) Länge + Feld 3.) Verkettete Liste

11 Allgemeines zu Zeichenketten Operationen (2) 11 Zugriff auf ein beliebiges Zeichen Einfügen und Löschen 1.) O(1) 1.) O(n) (alle nachfolgende Zeichen verschieben) 2.) O(1) 2.) O(n) (alle nachfolgende Zeichen verschieben) 3.) O(n) 3.) O(1) (Zeiger neu setzen) 1.) Feld + \0 2.) Länge + Feld 3.) Verkettete Liste

12 String Matching Allgemein 12 Zeichenfolge: 1. Text Buchstaben, Sonderzeichen und Ziffern Der Text ist meist sehr umfangreich Effiziente Algorithmen notwendig 2. Binärfolge Darstellung durch Einsen und Nullen (spezielle Text-Zeichenfolge) häufig bei Darstellung von Grafiken / Bilderverarbeitung Spezielle Algorithmen notwendig

13 String Matching Allgemein 13 String Matching: Suche nach dem exakten Muster Pattern Matching: Suche nach einem ähnlichen Muster Zwei verschiedene Problemstellungen bei der Suche in einem Text: (beide Punkte können sowohl ähnliche als auch exakte Muster beinhalten) 1. Muster vorgegeben, mehrere Texte danach durchsuchen schneller Suchalgorithmus notwendig 2. Text vorgegeben und nach mehreren Muster durchsuchen (DNA) komplexere und aufwändiger Vorverarbeitung möglich wobei die häufigen Muster unbekannt sind nennt sich auch Warenkorbanalyse oder Association rule mining

14 String Matching Naive Suche Idee 14 Problem: Finde in einem Text der Länge N ein vorgegebenes Muster der Länge M Idee: Vergleiche je Schritt ein Zeichen des Musters und ein Zeichen des Textes. Bei einer Nichtübereinstimmung wird das Vergleichsfenster um eine Position nach rechts geschoben

15 String Matching Naive Suche Beispiel 15 Der Text wird von links nach rechts mit dem Muster verglichen Übereinstimmungen sind grün markiert Die rot markierten Buchstaben zeigen die Nichtübereinstimmungen, bei deren Auftreten das komplette Muster um eine Position nach rechts geschoben wird

16 String Matching Naive Suche Der Algorithmus 16 int naive (char *text, int N, char *muster, int M) { int i = 0, j = 0; /*Solange Text noch nicht am Ende und Muster nicht ganz durchlaufen*/ while (j < M && i < N) { if (text[i] == muster[j]) { i++; j++; } else { i = i - j + 1; // Verschiebung des Musters um eine Stelle j = 0; Textlänge N } Musterlänge M } } Normalerweise M<<N /*Gibt Position beim Match und -1 beim Mismatch zurück*/ if (j == M) { return i - M; } else { return -1; }

17 String Matching Naive Suche Zusammenfassung 17 Zeichenweiser Vergleich von Text und Muster Zurücksetzen auf Anfangsposition + 1, wenn Zeichen nicht übereinstimmen Keine Vorbereitungsphase Im schlimmsten Fall N-M+1 Durchläufe der while-schleife und M Durchläufe der if-abfrage Aufwand: Im Durchschnitt lineare Laufzeit Worst-Case: O(M*N) Vergleiche: Erwartet maximal 2*N+M Vergleiche Average-Case: O(N) Vorbereitungsphase: keine Zus. Speicheraufwand: keiner

18 String Matching Knuth-Morris-Pratt Idee 18 Wie kann der naive Algorithmus verbessert werden? Idee: Stimmt der Text mit dem Muster an Position i nicht mehr überein, wissen wir bereits wie die Zeichen vor Position i aussehen und müssen den Zeiger nicht mehr komplett zurück setzen Durch einige Überlegungen kann sogar erreicht werden, dass i überhaupt nicht mehr dekrementiert werden muss!

19 String Matching Knuth-Morris-Pratt Randberechnung 19 Ausnutzung der bereits erfolgreich verglichenen Zeichen Betrachtung, wo im Muster die übereinstimmenden Zeichen noch einmal vorkommen Der Rand ist ein Teilwort der Zeichenkette, das sowohl am Anfang als auch am Ende der Zeichenkette vorkommt Das leere Wort Epsilon hat keinen Rand Ein einzelner Buchstabe hat als Rand das leere Wort Dadurch Verschiebungen um größere Bereiche möglich Verbesserung der Laufzeit

20 String Matching Knuth-Morris-Pratt Randberechnung 20 An Position i+j ist eine Nichtübereinstimmung aufgetreten (rotes Kästchen) Die vorhergehenden Zeichen haben übereingestimmt (hellgrün) Haben diese Zeichen einen Rand (dunkelgrün), kann das Muster soweit nach rechts geschoben werden, bis die Ränder übereinstimmen Das Vergleichsfenster startet wieder an Position i+j im Text

21 String Matching Knuth-Morris-Pratt Randberechnung 21 aabaa j i rand[j] i=0;i=-1; ababa j i rand[j] i=-1; i=1; i=2; i=3; Ränder können sich überlappen!

22 String Matching Knuth-Morris-Pratt Randberechnung 22 void init_rand (int *rand, char *muster, int M) { int i = 0, j; rand[0] = -1; /*Epsilon hat keinen Rand*/ rand[1] = 0; /* Ein einzelner Buchstabe hat als Rand das leere Wort*/ } for (j = 2 ; j <= M; j++) { /*Prüfe ob bestehender Rand erweiterbar ist*/ while (i >= 0 && (muster[i]!= muster[j-1])) { i = rand[i]; } i++; rand[j] = i; }

23 String Matching Knuth-Morris-Pratt Der Algorithmus 23 int KMP (char *text, int N, char *muster, int M) { int i=0, j=0; int rand[m + 1]; init_rand (rand, muster, M); /*Vorverarbeitung: Ränder berechnen */ while (i <= N - M) { while (text[i + j] == muster[j]) { j++; if(j == M) { return i; // Stelle des Matches ausgeben } } } i = i + j rand[j]; /*j rand[j] > 0! */ j = max{0, rand[j]}; } return -1;

24 String Matching Knuth-Morris-Pratt Laufzeitanalyse 24 KMP ist geeignet für inkrementelle Suche (z.b. Firefox, Emacs) Der Suchalgorithmus findet bereits eingegebene Präfixe des Musters Die Randtabelle wird inkrementell für den bekannten Teil des Suchwortes berechnet und mit jedem neuen Zeichen erweitert Vergleiche: Tabellenberechnung 2*M-1 Vergleiche Aufwand: Worst-Case: O(N+M) KMP-Algorithmus 2*N-M+1 Vergleiche Insgesamt maximal 2*N+M Vergleiche Avarage-Case: O(N) Vorbereitsungsphase: O(M) Zus. Speicheraufwand: O(M)

25 String Matching Knuth-Morris-Pratt Zusammenfassung 25 Vergleicht von links nach rechts KMP behält lineare Laufzeit im Worst-Case bei Starke Verbesserung für selbstwiederholende Muster (Bitfolgen) Ansonsten keine nennenswerten Vorteile gegenüber Naiver Suche ABER: Sequentielles Durchlaufen ohne Zurücksetzen geeignet für Dateneinlesen von externen Geräten

26 String Matching Boyer-Moore Idee 26 Wie kann eine weitere Verbesserung erreicht werden? Idee: Vergleich von Muster und Text von rechts nach links! Den nächsten Schritt ausführen auf Basis des Musters des Zeichens das die Nichtübereinstimmung ausgelöst hat Voraussetzung: Das Zurücksetzen darf nicht kompliziert sein.

27 String Matching Boyer-Moore 27 Der Boyer-Moore Algorithmus setzt sich aus 2 Strategien zusammen: 1. Strategie für unpassende Zeichen (Bad-character-heuristics) Das Zeichen, das den Mismatch ausgelöst hat, kommt im Muster nicht vor Verschiebung um M Positionen möglich Das Zeichen, das den Mismatch ausgelöst hat, kommt im Muster vor Muster in Übereinstimmung mit diesem Zeichen bringen kommt das Zeichen mehr als ein Mal vor, wird das Muster mit dem am weitesten rechts stehenden Zeichen in Übereinstimmung gebracht

28 String Matching Boyer-Moore Vergleich e und r : e kommt im Muster an Position 2 vor Muster um 5 Positionen nach rechts schieben 2. Vergleich t und r : t kommt im Muster nicht vor Muster um 7 Positionen nach rechts schieben usw.

29 String Matching Boyer-Moore Gutes-Ende - Strategie (Good-suffix-heuristics) Das Suffix, das hinter dem Zeichen, welches den Mismatch ausgelöst hat, steht, kommt noch an anderer Stelle im Muster vor und kann bis dorthin verschoben werden Das Suffix kommt vollständig noch einmal im Muster vor

30 String Matching Boyer-Moore 30 Das Suffix kommt nur teilweise im Muster vor Das Suffix kommt nicht mehr im Muster vor Verschiebung um M Positionen nach rechts

31 String Matching Boyer-Moore Der Algorithmus 31 int BM (char *text, int N, char *muster, int M) { int i=0, j, temp1, temp2; int f[m+1], goodsuffix[m+1], badchar[asize]; } initsz (badchar, ASIZE, muster, M); /* Vorverarbeitung: */ initge1 (goodsuffix, f, muster, M); /* Schiebematrizen berechnen*/ initge2 (goodsuffix, f, muster, M); while (i <= N-M) { } return -1; /*ASIZE = Alphabetgröße*/ j = M-1; while (j >= 0 && (muster[j] == text[i+j])) j--; if (j < 0) { return i; /*Matchposition zurueck geben*/ } /*Wähle groesseren Shift aus beiden Strategien aus*/ i += max (j - badchar[text[i+j]- a ], goodsuffix[j+1]);

32 String Matching Boyer-Moore Bad-Character-Shift 32 void initsz (int *badchar, int asize, char *muster, int M) { int i; char a; /*Falls das Symbol im Muster nicht vorkommt hat es den Wert -1*/ for (i = 0; i < asize ; i++) { badchar[i] = -1; } /*Speichere den Shift für die am weitesten rechts stehenden Symbole des Musters*/ for (i = 0; i < M ; i++) { a = muster[i]; badchar[a - a ] = i; } }

33 String Matching Boyer-Moore Good-Suffix Shift 33 Fall 1: Das übereinstimmende Suffix kommt noch an anderer Stelle im Muster vor ähnlich KMP-Vorbereitungsphase, bestimme zu jedem Suffix die Ränder Zuordnung zwischen gegebenem Rand und kürzestem Suffix, das den Rand hat prüft ob sich ein bereits berechneter Rand fortsetzen lässt für ein Suffix das bei i beginnt, beinhaltet das Feld f[i] die Position seines breitesten Randes Fall 2: Nur ein Teil des übereinstimmenden Suffixes kommt noch im Muster vor belegt die noch freien Einträge von goodsuffix[] Fall 3: Das Suffix kommt gar nicht mehr im Muster vor Verschiebung um M Positionen

34 String Matching Boyer-Moore Gutes-Ende Shift Fall 1 34 void initge1 (int *shift, int *f, char *muster, int M) { int i, j; i = M; j = M +1; f[i] = j; /*Suffix Epsilon (Position M) wird auf M+1 gesetzt*/ } while (i > 0) { while (j <= M && (muster[i-1]!= muster[j-1])) { if (shift[j] == 0) shift[j] = j - i; j = f[j]; } i--; j--; f[i] = j; }

35 String Matching Boyer-Moore Gutes-Ende Shift Fall 2 35 void initge2 (int *shift, int *f, char *muster, int M) { int i,j; j = f[0]; /*f[0] ist breitester Rand des Musters*/ } for (i = 0 ; i <= M ; i++) { /*falls durch GE1 noch nichts eingetragen wurde*/ if (shift[i] == 0) shift[i] = j; if (i == j) j = f[j]; /*Umschalten auf nächstschmaleren Rand*/ }

36 String Matching Boyer-Moore Laufzeitanalyse 36 Vergleiche: Maximal 3(N + M) Textzeichenvergleiche Aufwand: Worst-Case: O(N*M)!! Average-Case: Best-Case: Vorbereitungsphase: O(N) O(N/M) O(M) Zus. Speicheraufwand: O(M)

37 String Matching Boyer-Moore Zusammenfassung 37 Vergleicht von rechts nach links!! Oftmals Verschiebungen um M Positionen möglich wegen der schlechten-zeichen und Guten-Ende - Strategie Im Worst-Case schlechter als KMP, in der Praxis schnellster String-Matching Algorithmus Besonders geeignet für Texte mit vielen Symbolen große Shifts Weniger geeignet für Bitmuster und DNA-Sequenzen, da wegen dem kleinen Alphabet nur wenige schlechte-zeichen Verschiebungen vorkommen und diese Muster oft Wiederholungen enthalten Schiebedistanzen werden kleiner mehr Vergleiche Häufige Verwendung für die Suche in Texteditoren

38 String Matching Rabin-Karp Idee 38 Gibt es vielleicht noch einen ganz anderen Ansatz? Idee: Aus dem Muster wird per Hash-Funktion ein Schlüssel berechnet. (Dieser passt in eine Speicherzelle schnelle Verarbeitung!) Vergleiche den Schlüssel eines Textabschnittes der Länge M mit dem Schlüssel des Muster Es wird quasi ein Fingerabdruck des Musters genommen! Voraussetzungen: Berechnung des Textschlüssels in O(1) Streufunktion muss sehr viele Werte liefern q muss >> M sein

39 String Matching Rabin-Karp Berechnung des Schlüssels 39 Vorbereitungsphase: Berechnung der beiden Schlüssel von Muster und den ersten M Zeichen des Textes Die Berechnung kann z.b. auch mittels dem Hornerschema erfolgen key = text[ i]* basis M 1 + text[ i + 1]* basis M text[ i + M 1] Suchphase: Der Schlüssel des Textes muss sich leicht aus dem Schlüssel des vorherigen Textabschnittes berechnen lassen key = ( key text[ i]* basis M 1 )* basis + text[ i + M ] Wegen der großen Zahlen muss man darauf achten, dass kein Überlauf eintritt!

40 String Matching Rabin-Karp Textschlüsselberechnung 40 Wegen der Streufunktion muss bei einer Übereinstimmung immer noch Zeichenweise verglichen werden, um sicher zu gehen, dass es sich um keine Kollision handelt! Beispiel: Text = q = 13 M = 5 key = keyneu = ( * 10000) * (mod 13) = ( 7 3 * 3 ) * (mod 13) = 8 (mod 13)

41 String Matching Rabin-Karp Beispiel mod 11 = 3

42 String Matching Rabin-Karp Der Algorithmus 42 int KR (char *text, int N, char *muster, int M) { int h1=0, h2=0, dm = 1, i; int q = ; //Primzahl für Streufunktion for (i = 1 ; i < M ; i++) /*Berechnung der höchsten Potenz*/ dm = basis *dm %q; for (i = 0 ; i < M ; i++) /*Berechnung des Musterschlüssels*/ h1 = (h1 * basis + muster[i] a ) % q; for (i = 0 ; i < M ; i++) /*Berechnung des ersten Textschlüssels*/ h2 = (h2 * basis + text[i] - a ) % q; } for (i = 0 ; i <= N M; i++) { if (h1 == h2 && memcmp(muster,text+i,m) == 0) return i; h2 = (h2 + basis * q - (text[i] a ) * dm) % q; h2 = (h2 * basis + (text[i + M] a ) ) % q; //h2 beinhaltet den Schlüssel zum aktuellen Textfenster } return -1;

43 String Matching Rabin-Karp Laufzeitanalyse 43 Aufwand: Worst-Case: Average-Case: Vorbereitungsphase: O(N*M) O(N+M) O(M) Zus. Speicheraufwand: keiner

44 String Matching Rabin-Karp Zusammenfassung 44 Vergleicht ähnlich dem naiven Algorithmus einzelne Textfenster Hashfunktion bildet Muster und Textfenster auf eine Zahl ab Benötigt keine Hashtabelle Hat in den allermeisten Fällen eine lineare Laufzeit Eignet sich auch für 2-dimensionales Matching

45 Tries 45 I think that I shall never see A poem lovely as a tree. Poems are made by fools like me, But only God can make a tree. Joyce Kilmer, "Trees," 1914

46 Tries 46 Wortverquickung von tree und re-trie-val (Suchen, Wieder finden) Ist eine Datenstruktur, in der eine Menge von Wörtern abgespeichert werden kann Schlüssel sind die Pfade von der Wurzel zu einem Blatt Kanten, die vom gleichen Knoten ausgehen müssen verschiedene Beschriftungen haben

47 Tries Beispiel 47

48 Suffix-Tries 48 Ein Suffix-Trie ist ein Trie für alle Suffixe des Wortes Suffix Index Damit kein Suffix Präfix eines anderen Suffixes ist wird $ ans Ende jedes Suffixes gehängt

49 Suffix-Tries Beispiel für abbaba$ 49

50 Suffix-Tries Anwendungen 50 Prüfen, ob Muster der Länge M Teilstring des Textes ist in O(M) Die Anzahl z der Muster in dem Text in O(M+z) finden Nach einem regulären Ausdruck in linearer Zeit suchen Nach einem Muster mit x Mismatchen suchen O(M*sigma+x+z) (Pattern Matching) Finden des längsten gemeinsamen Teilwortes aller Zeichenketten ( longest common substring problem ) in O(n) Das am häufigsten auftauchende Teilwort minimaler Länge in O(n) Beispiele: Bioinformatik DNA Analyse Datenkomprimierung (sich wiederholende Daten finden) Compilerbau: Precedural abstraction

51 Suffix-Tries Aufbau 51 Wie erstelle ich einen Suffix-Trie? Naiver Ansatz: Füge alle Suffixe vom größten bis zum kleinsten der Reihe nach ein Aufbauen des Suffix-Tries mit der naiven Methode: O(N³) Verbesserung: Speichere am Ende jedes Suffixes einen Verweis auf das nächste kürzere Suffix Aufbau zusammen mit Suffix-Links: O(N²) Größe des Suffix-Tries (Knotenanzahl): O(N²) Optimierung notwendig!

52 Suffix-Tries Aufbau mit Suffix-Links 52

53 PATRICIA-Tries 53 Practical Algorithm to Retrieve Information Coded in Alphanumeric Kompaktifizierung durch Zusammenfassen von Knoten mit nur einem Kind zu einer Kante kompaktifizierte Suffix-Tries nennt man Suffix-Trees Dadurch weniger Knoten, aber eine größere Kantenbeschriftung Lösung durch Verwendung von Referenzen Verbesserung des Platzbedarfs und der Laufzeit

54 PATRICIA-Tries Beispiel 54

55 Suffixtries Ukkonens Online Algorithmus 55 Sehr komplizierter Algorithmus, dafür Aufbau in linearer Zeit möglich Ansatz ist wie beim Suffix-Trie Das Suffix endet aber nicht zwangsläufig in einem Knoten Verbessert die Laufzeit durch Vorverarbeitung des Textes Aufbau des Suffix-Tries in O(N) Zusätzlicher Speicherplatz: O(N)

56 Zusammenfassung und Ausblick 56 Welcher Suchalgorithmus verwendet werden sollte hängt vom jeweiligen Anwendungsfall ab: Pattern-Matching String-Matching Einfachsuche Mehrfachsuche Beachte, ob sich der algorithmische Aufwand überhaupt lohnt! Für kurze Zeichenketten reicht eventuell schon der naive Algorithmus oder man strstr

57 Literaturverzeichnis Bücher 57 Volker Heun, Grundlegende Algorithmen, 2.Auflage, Friedr. Vieweg & Sohn Verlag Robert Sedgewick, Algorithmen, 1. Auflage, Addision-Wesley Cormen, Rivest, Stein,Leiserson, Introduction to Algorithms, 2nd Edition, MacGraw- Hill Book Company Uwe Schöning, Algorithmik, 1.Auflage, Spektrum Akademischer Verlag GmbH Skiena, Revilla, Programming Challenges, 1st Edition, Springer Verlag

58 Literaturverzeichnis Internet 58 [1]Skriptum zur Vorlesung Algorithmische Bioinformatik I/II, Volker Heun, TU München [2] Exakt String Matching Algorithms, Christrian Charras, Université de Rouen [3]Textsuch-Algorithmen, H.W. Lang, FH Flensburg [4]Allgemeines zu Zeichenketten und String-Matching

59 Grafikverzeichnis 59 Folie Grafiktitel Quelle 5 ASCII-Tabelle [4] 16 Naiver Algorithmus 20 Randverschiebung [1] Seite Bad-Character Shift 29 Good-Suffix-Shift [2] Boyer-Moore 40 Karp-Rabin 46 Monatsnamen-Trie [1] Seite Suffix-Trie [1] Seite Suffix-Links [1] Seite Patricia-Trie 2 [4] Suffix_tree