PROJET INFORMATIQUE RECHERCHE DE SOUS-CHAÎNE DE CARACTERES I-Présentation Un algorithme de recherche de sous-chaine est un type d'algorithme de recherche qui a pour objectif de trouver une chaîne de caractères à l'intérieur d'une autre chaîne de caractère. Ainsi, cet algorithme renvoie la position du premier caractère de la sous-chaîne recherchée dans la chaîne initiale. En programmation, de nombreuses informations sont représentées sous forme de chaînes de caractères que ce soit des lettres, des chiffres On existe aussi des chaînes binaires composées d'une suite de 0 et de 1. Pour trouver un motif (une sous chaine de caractères) dans un long texte (chaine de caractère principal), il nous faut un algorithme de recherche de ce motif. On cherche à trouver la méthode la plus rapide et efficace pour ce genre de problème. On réalise l'opération suivante : On fait un appariement de motifs, c'est-à-dire, qu on cherche les occurrences d'un motif de longueur M dans un texte de longueur N sachant que N est plus grand que M. Nous allons étudier plusieurs algorithmes connus, et tester deux implémentations en Java.
II- Histoire de la recherche. Au début, l'algorithme naïf avait pour la plupart du temps une complexité de O(M+N), mais de O(MN) dans le pire cas pour trouver une chaine de caractère dans un texte. Mais dans les années 70, il a été démontré l'existence d'un algorithme en O(M+N) dans le pire cas Ainsi, l algorithme Knuth-Pratt-Morris voit le jour en 1975. A l origine, c est Knuth et Pratt associés qui trouvèrent en premier la solution. Mais au même moment, Morris trouva quasiment la même solution tout en utilisant une autre méthode. Peu après, un algorithme plus efficace fut découvert par Boyer et Moore Mais, ces deux algorithmes de Knuth-Morris-Pratt et de Boyer-Moore sont accessibles qu à partir d un pré-traitement d informations important ce qui le rend moins rapide. En 1980, Karp et Rabin publièrent un algorithme dont l implémentation se révèle plus simple tout en gardant une complexité en O(M+N). II- Différents algorithmes et principes 1) Algorithme naïf Le principe est simple, on cherche une sous-chaîne x de longueur m dans un texte t de longueur n, tout en vérifiant que le texte soit plus grand que la sous chaine. A partir de la chaine principe, on parcourt caractère après caractère, si la sous chaine correspond. On parcourt ainsi les caractères de la chaîne initiale jusqu à ce qu un caractère coincide avec le premier caractère de la sous-chaine Dans ce cas, on parcourt les caractères suivants tant qu'ils correspondent à la souschaine. Dans le cas où un caractère change, alors on reprend la boucle de recherche du premier caractère identique, à partir du caractère suivant dans la chaîne initiale. Dans le cas où tous les caractères sont identiques, on renvoie la position du premier caractère de la chaîne trouvée dans la chaîne initiale. Pour finir, si aucune sous chaine n est retrouvé, l algorithme renvoie un message d erreur.
Schéma du principe de l algorithme naïf. Implémentation Algorithme Naïf : package projet; public class Recherche2 { public static void algo(string text, String souschaine){ // Taille du texte int m = text.lenght() ; // Taille de la sous-chaine int n = souschaine.length(); if(m<n) System.out.println("La chaine de caractère est plus petite que la sous chaine."); else{ // Création d'un booléan qui retourne si la sous-chaine a été trouvée. boolean resultat = false; int i = 1; int j = 0; // Création d'un compteur qui renvoie la position de la sous chaine dans le texte.
int compteur =1; while (i <= n && j <= m && resultat!= true){ //Si la sous chaine de caractère se trouve au tout début du texte, on arrete la boucle et renvoie la //position 1. if (text.substring(0, n).equals(souschaine)){ System.out.println("La sous-chaine existe dans le texte en position "+compteur); resultat = true; //Sinon, on enlève le premier caractère du texte, et on relance la boucle else { text =text.substring(1,m); //Augmentation d'une unité du compteur compteur ++; //Baisse d'une unité de la longueur du texte; m=m-1; // Passage au caractère suivant du texte j = j - i + 2; i = 1; if(resultat ==false) System.out.println("La sous-chaine n'existe pas."); public static void main(string [] args){ String text = "eeeabc"; String souschaine = "abc"; algo(text, souschaine); Au pire cas, cet algorithme a une compléxité de O(MN), mais en réalité dans un texte, l'algorithme naïf nécessite seulement O(N) comparaisons.
Nous avons, de plus, implémenté une autre méthode très basique pour rechercher une sous-chaine de caractère dans un texte : package projet; public class Recherche { public static void main(string [] args){ // On crée une chaine de caractère String nom = new String("Alexandre Gauttier et Audrey Gobin Projet"); if(nom.length() ==0) System.out.println("La chaine de caractère est nulle"); else{ // On crée un entier qui donnera la position du début de la sous-chaine de caractère, ou qui donne -1 // Si la sous-chaine de caractère n'existe pas. int ouest = nom.indexof("et"); if(ouest == -1) System.out.println("La sous chaine de caractère n'existe pas."); else System.out.println("La sous chaine de caractère existe, elle commence à la position "+(ouest+1)); Cette méthode permet de trouver une sous chaine de caractère dans une chaine principale. On crée tout d abord une variable String qui aura pour contenu la chaine de caractère principale dans laquelle on exécutera notre recherche. Puis, grâce à la méthode indexof(string), on peut pour n importe quelle sous chaine de caractère, vérifier si elle existe, et voir sa position dans la chaine de caractère. En effet, la fonction.indexof(sous-chaîne) permet de retrouver (dans la chaîne principale initialisé dans la variable String) la position du premier caractère de la sous-chaîne recherchée, si jamais celle-ci existait.
On crée ensuite une variable de type int, qui renvoie -1 si la sous-chaine de caractère n existe pas, ou la position du premier caractère de la sous chaine (auquel on ajoutera 1 unité car la fonction commence à la position 0). Cette méthode a une limite. Elle ne prend pas en compte si la sous chaine de caractère se trouve à plusieurs reprises dans la chaine de caractère. 2) Algorithme de Knuth-Morris-Pratt Cet algorithme inventé en 1975 permet d obtenir de meilleurs résultats que la méthode naïve. En effet : Dans l'algorithme naïf, lorsqu'un un caractère du motif est différent du caractère correspondant dans le texte, la recherche reprend à la position suivante en repartant au début du motif. L algorithme naïf peut être couteux, prenons par exemple le texte «aaaaaaaaaaaaaaaaaaaaab» et le motif «ab». L'idée de l'algorithme de Knuth Morris Pratt est d'éviter des comparaisons inutiles. On effectue un pré-traitement de la sous-chaîne afin de savoir si l on continue la recherche, en cas de non correspondance avec le texte à un certain indice. Ainsi l algorithme ne ré-examine pas les caractères précédemment vérifier. Cela limite le nombre de comparaisons nécessaires. En effet, par exemple, si l on recherche le motif : abcdabd dans le texte : abc abcdab abcdabd, l on remarque une divergence au niveau de la quatrième étape de comparaison. L algorithme ayant enregistré les lettres du textes déjà parcouru (i.e. abc ), il sait qu il n y a aucun a de présent, mise à part la première lettre, et avance donc directement à la cinquième lettre du texte pour recommencer la comparaison. Celle-ci échoue encore une fois, mais l algorithme à cette fois-ci repérer la suite ab et recommence donc à cette endroit (soit la 9ème lettre du texte). Les deux premières lettres n ont alors pas besoin d être vérifiées.
Cet algorithme a une complexité moyenne de 0(N+M) et de 0(N) dans le pire cas. Schéma du principe de l algorithme Knuth-Morris-Pratt Pseudo-code KMP : Variables Entiers k, i, j, M, N ; String texte, motif; Début M <- longueur de texte ; N <- longueur de motif ; Pour i allant de 0 à M-1 Faire Pour j allant de 0 à N-1 Faire Tant que (texte[i] = motif[j]) Faire j++ ; i++ ; Fin Tant que Pour k allant de 0 à i Faire Si (occurrence de texte[k] = motif[0]) Alors j <- 1 ; i <- k+1 ; Sinon j <- 0 ; Fin si Fin pour Fin pour Fin pour Fin
3) Algorithme de Boyer-Moore Quand on compare le motif au texte, en fonction de la lettre du texte ayant induit la différence, on décale le motif vers la droite de manière à faire coïncider cette lettre avec l occurrence la plus à droite de la même lettre dans le motif. Cet algorithme datant de 1977 est une succession de tentatives (comparaison entre les deux String) et de décalage de la sous-chaîne vers la droite. Il compare le motif au texte, en fonction de la lettre du texte ayant induit la différence. Il décale ensuite le motif vers la droite de manière à faire coïncider cette lettre avec l occurrence la plus à droite de la même lettre dans le motif. Par exemple, si l on recherche le motif : abc dans le texte : dcf-gjgb-abc, cela commence par l alignement du motif et du texte à gauche (sens de lecture normal), mais en regardant en premier lieu la lettre la plus à droite du motif. C est-à-dire une comparaison de c pour la sous-chaîne, avec la 3 ème lettre du texte qui est donc f. Non seulement ce ne sont pas les mêmes lettres, mais il n existe en plus aucun f dans le motif. L algorithme décale alors la sous-chaîne en sautant les 3 premières cases du texte. On a alors : dcf-gjbf-abc abc On réitère donc la même procédure : démarrer par la dernière lettre du motif, et on remarque une nouvelle fois que le c de celui-ci ne coïncide pas avec b. Cependant, l algorithme remarque qu il y a un b dans le motif, et le décale donc pour les mettre à la même position : dcf-gjbf-abc abc L opération recommence jusqu à trouver la sous-chaîne désirée. Cet algorithme a, en théorie, une complexité de 0(N/M) dans le cas le plus favorable, et un temps en moyenne peu supérieur à celui du meilleur cas. La complexité est de 0(N+M) dans le pire cas.
Schéma de l algorithme de Boyer-Moore. Prototype de Pseudo code : Algorithme Boyer-Moore Variables Entiers i, j, M, N ; String texte, motif; Début M <- longueur de texte ; N <- longueur de motif ; Pour i allant de 0 à M-1 Faire Pour j allant de N-1 à 0 Faire Tant que (j!= i) Faire Si (texte[i] n appartient pas au motif) Alors j <- N-1 ; i <- i + j ; Sinon j <- N-1 ; i <- l occurrence où texte[i] = motif [j] ; Fin si Fin tant que Fin pour Fin pour Fin
4) Algorithme Rabin-Karp Cet algorithme apparu en 1980, utilise une fonction de hachage, afin d éviter les comparaisons inutiles. En effet, pour chaque mot du texte est associé un entier égal au nombre de lettre de ce mot (ou de chiffre ) Ainsi, lorsque la comparaison commence, l algorithme regarde en premier lieu s il y a égalité du nombre de caractère en position i, entre le premier mot du texte, et le motif. Si ce n est pas le cas la comparaison n est pas réalisée et on passe directement au mot suivant en incrémentant i à 1 afin de recommencer le même processus. La complexité moyenne de cet algorithme est de 0(N+M) en moyenne, et de 0(NM) dans le pire cas. 5) Recherches multiples Lorsque l on veut rechercher en même temps plusieurs (p) motifs dans un texte, on peut utiliser un mélange de plusieurs algorithmes. La première idée consiste à appliquer p fois un des algorithmes précédents. Cela implique qu il faut passer p fois sur le texte. Par exemple, si on utilise comme algorithme de base Knuth-Morris-Pratt on obtient alors l algorithme de Aho et Corasick (1975). Si on utilise Boyer-Moore on obtient l algorithme de Commentz-Walter (1979) qui est plus rapide. Aho-Corasick L'algorithme consiste à avancer dans une structure de données qui contient le ou les mots recherchés en lisant les lettres du texte une par une. Généralement la structure de données est implantée à l'aide d'un trie, ce qui garantit que chaque caractère du texte n est lue qu une seule fois. L'algorithme se déplace progressivement dans le texte en entrée et en conservant la correspondance la plus longue. Il extrait toutes les occurrences des motifs (chaine de caractère). On a pour cette algorithme une complexité linéaire.