ALGORITMO DE BOYER MOORE

HORSPOOL EN C++
Caractersticas

Es una simplificacin del algoritmo de Boyer-Moore.

Es fcil de implementar.

Existe un preprocesamiento del patrn.

Necesita O()en espacio y O(m+)en tiempo (por el preprocesamiento).

Realiza saltos determinados en el preprocesamiento.

Compara de derecha a izquierda.

Realiza la bsqueda del patrn en un tiempo O(mn).

Realiza un nmero promedio de comparaciones para un carcter entre 1/y 2/

(+1).
Lgica

Se calcula el preprocesamiento del patrn de la siguiente forma:

Se calcula la distancia mnima entre el ltimo carcter y la ocurrencia de cada

carcter del alfabeto de la hilera principal.

Para realizar la bsqueda:

Consiste en la comparacin de cada carcter del texto con las posiciones del patrn en el
orden m-1, 0, 1, 2, , y m-2, si se da una ocurrencia del patrn o no.
Cuando se encuentra una no ocurrencia, al hacer la primera comparacin entre el patrn y
el

texto,

el

salto

se

calcula

bmBc[c],

donde

ces

el

carcter

del

texto.

Cuando se encuentra una no ocurrencia o una ocurrencia total, al hacer las siguientes
comparaciones entre el patrn y el texto, el salto se calcula bmBc[c], donde ces el carcter
del patrn.
Descripcin
Es considerado el mejor algoritmo de bsqueda de un patrn en un texto en aplicaciones
usuales.
El algoritmo escanea los caracteres del patrn con el texto iniciando con el carcter ms a
la derecha.
En caso de una no ocurrencia o una ocurrencia total del patrn se usa una funcin
preprocesada para saltar:

Salto del mal carcter(bad-character shift) (o salto de ocurrencia).

Horspool propuso utilizar solamente el salto del mal carcter para calcular los saltos en el
algoritmo de Boyer-Moore.
El salto del mal carcter consiste en:
Alinear cada carcter del alfabeto con la ocurrencia ms a la derecha en x[0, , m-2].
Si el carcter no ocurre en el patrn x, la no ocurrencia de x puede incluir el carcter, y
alinearlo en el lado ms izquierdo del patrn.
Esta operacin (usada en el algoritmo BM) no es muy eficiente para alfabetos pequeos,
pero cuando el alfabeto es grande comparado con la longitud del patrn llega a ser muy
til. Usarlo slo produce un algoritmo muy eficiente en la prctica.
Ejemplo
El algoritmo encuentra todas las ocurrencias del patrn en el texto.
El patrn se denota por x = x[0, ..., m-1]; su longitud es igual a m.
El texto se denota por y = y[0, ..., n-1]; su longitud es igual a n.
Ambas secuencias son estructuras sobre un sistema finito de caracteres llamado
alfabetodenotado por S, con tamao igual a s.
x = GCAGAGAG
y = GCATCGCAGAGAGTATACAGTACG

Implementacin

/*
* C++ - Algoritmo de Boyer Moore Horspool
*
* Copyright 2014 Martin Cruz Otiniano
*

* Site: www.marcsdev.com
*/
#include<iostream>
#include <stdlib.h>
#include<string.h>
#include<time.h>
#define MAXT 1001
#define MAXP 1000
using namespace std;
char
char
signed int
signed int

texto[MAXT] ;
patron[MAXP] ;
rep ;
comp ;

// numero de veces encontrado

// numero de comparaciones

/******************** Busqueda por Boyer Moore Horspool

****************************/
void preBMBc(char *P, int m, int tabla[])
{
int i;
for (i = 0; i < 256; ++i)
tabla[i] = m;
for (i = 0; i < m - 1; ++i)
{
tabla[P[i]] = m - i - 1;
}
}
void BMH( char *T, int n , char *P, int m)
{
int j , bmBC[256] ;
char c ;
preBMBc(P, m, bmBC) ;

// Preprocesamiento

// Bsqueda
j = 0;
while (j <= n - m)
{
c = T[j + m - 1] ;
if ( P[m - 1] == c && memcmp(P, T + j, m - 1) == 0 )
{
cout<<" * Encontrado en : "<< j + 1 << endl;
rep ++ ;
}

j = j + bmBC[c] ;

comp ++ ;

}
}
/*************************** Funcion Principal *****************************/
int main()
{
system("color 0B" );
float t1 , t2, tiempo ;
rep = 0 ;

// variables pata tiempo de busqueda

cout<<endl ;
cout<<"\t "<<endl;
cout<<"\t ALGORITMO BOOYER M. HORSPOOL "<< endl ;
cout<<"\t ---------------------------------------------- "<< endl ;
cout<<"\t
"<<endl<<endl;
cout<<endl<<" Ingrese Texto : \n\t\t" ;
gets( texto ) ;
cout<<endl<<" Ingrese Patron : \n\t\t" ;
gets( patron ) ;
int n
int m

= strlen( texto ) ;
= strlen( patron ) ;

cout<<"\n__________________________________________________________"<<endl<<en
dl;
t1 = clock();
BMH( texto , n , patron , m ) ;
t2 = clock();

cout<<"\n__________________________________________________________"<<endl<<en
dl;
tiempo = (t2-t1)/100000 ;
cout<<endl<<" >> Tiempo de busqueda : "<< tiempo ;
if(rep == 0)
cout<<endl<<endl<<" >> Patron no encontrado ..! " ;
else
cout<<endl<<endl<<" >> Ocurrencias : "<< rep ;
cout<<endl<<endl<<" >> Comparaciones : "<< comp ;

cout<<"\n\n__________________________________________________________"<<endl<<
endl;

system("pause");
return 0;
}