Algoritmo de búsqueda de cadenas Boyer-Moore

El algoritmo de búsqueda de cadenas Boyer-Moore es un particularmente eficiente algoritmo de búsqueda de cadenas, y ha sido el punto de referencia estándar para la literatura de búsqueda de cadenas práctica.^[1] Fue desarrollado por Bob Boyer y J Strother Moore en 1977. El algoritmo preprocesa la cadena objetivo (clave) que está siendo buscada, pero no en la cadena en que se busca (no como algunos algoritmos que procesan la cadena en que se busca y pueden entonces amortizar el coste del preprocesamiento mediante búsqueda repetida). El tiempo de ejecución del algoritmo Boyer-Moore, aunque es lineal en el tamaño de la cadena siendo buscada, puede tener un factor significativamente más bajo que muchos otros algoritmos de búsqueda: no necesita comprobar cada carácter de la cadena que es buscada, puesto que salta algunos de ellos. Generalmente el algoritmo es más rápido cuanto más grande es la clave que es buscada, usa la información conseguida desde un intento para descartar tantas posiciones del texto como sean posibles en donde la cadena no coincida.

Cómo funciona el algoritmo

La gente frecuentemente le sorprende el algortimo de Boyer-Moore, cuando lo conoce, porque en su verificación intenta comprobar si hay una coincidencia en una posición particular marchando hacia atrás. Comienza una búsqueda al principio de un texto para la palabra "ANPANMAN", por ejemplo, comprueba que la posición octava del texto en proceso contenga una "N". Si encuentra la "N", se mueve a la séptima posición para ver si contiene la última "A" de la palabra, y así sucesivamente hasta que comprueba la primera posición del texto para una "A".

La razón por la que Boyer-Moore elige este enfoque está más clara cuando consideramos que pasa si la verficación falla-por ejemplo, si en lugar de una "N" en la octava posición, encontramos una "X". La "X" no aparece en "ANPANMAN", y esto significa que no hay coincidencia para la cadena buscada en el inicio del texto-o en las siguientes siete posiciones siguientes, puesto que todas fallarían también con la "X". Después de comprobar los ocho caracteres de la palabra "ANPANMAN" para tan sólo un carácter "X", seremos capaces de saltar hacia delante y comenzar buscando una coincidencia en el final en la 16.ª posición del texto.

Esto explica por qué el rendimiento del caso promedio del algoritmo, para un texto de longitud n y patrón fijo de longitud m, es n / m: en el mejor caso, solo uno en m caracteres necesitan ser comprobados. Esto también explica el resultado algo contra-intuitivo de que cuanto más largo es el patrón que estamos buscando, el algoritmo suele ser más rápido para encontrarlo.

El algoritmo precalcula dos tablas para procesar la información que obtiene en cada verficiación fallada: una tabla calcula cuantas posiciones hay por delante en la siguiente búsqueda basada en el valor del carácter que no coincide; la otra hace un cálculo similar basado en cuantos caracteres coincidieron satisfactoriamente antes del intento de coincidencia fallado. (Puesto que estas dos tablas devuelven resultados indicando cuán lejos "saltar" hacia delante, son llamada en ocasiones "tablas de salto", que no deberían ser confundidas con el significado más común de tabla de saltos en ciencia de la computación.) El algoritmo se desplazará con el valor más grande de los dos valores de salto cuando no ocurra una coincidencia.

Tabla primera

Rellénese la primera tabla como sigue. Para cada i menor que la longitud de la cadena de búsqueda, constrúyase el patrón consistente en los últimos i caracteres de la cadena precedida por un carácter no-coincidente, alinéense a la derecha el patrón y la cadena, y anótese el menor número de caracteres para que el patrón tenga que desplazarse a la izquierda para una coincidencia.

Por ejemplo, para la búsqueda de la cadena ANPANMAN, la tabla sería como sigue:
(NMAN significa una subcadena en ANPANMAN consistente en un carácter que no es 'N' más los caracteres 'MAN'.)

La cantidad de desplazamiento calculada por la primera tabla es a veces llamada "desplazamiento de sufijo bueno"^[2] o "regla de sufijo bueno (fuerte)". El algoritmo original Boyer-Moore publicado^[3] usa una más simple, más debil, versión de la regla de sufijo bueno en que cada entrada en tabla de arriba no requiere una no-coincidencia para el carácter de más a la izquierda. Esto es a veces llamado "regla del sufijo bueno débil" y no es suficiente para conseguir que Boyer-Moore funcione en tiempo lineal en el peor caso.

Tabla segunda

La segunda tabla es fácil de calcular: iniciése en el último carácter de la cadena vista y muévase hacia el primer carácter. Cada vez que usted se mueve a la izquierda, si el carácter sobre el que está no está en ya en la tabla, añádalo; su valor de desplazamiento es la distancia desde el carácter más a la derecha. Todos los otros caracteres reciben un valor igual a la longitud de la cadena de búsqueda.

Ejemplo: Para la cadena ANPANMAN, la segunda tabla sería como se muestra (por claridad, las entradas son mostradas en el orden que serían añadidas a la tabla): (La N que se supuestamente sería cero está basada en la segunda N desde la derecha porque solo anotamos el cálculo para las primeras m − 1 letras)

La cantidad de desplazamiento calculada por la segunda tabla es a veces llamada "desplazamiento de carácter malo".^[2]

Rendimiento del algoritmo de búsqueda de cadenas Boyer-Moore

El caso peor para encontrar todas las coincidencias en un texto necesita aproximadamente 3n comparaciones, de aquí que la complejidad sea O(n), a pesar de que el texto contenga una coincidencia o no.^[4] Esta prueba llevó algunos años para desarrollarse. En el año en que se ideó el algoritmo, 1977, se mostró que el número máximo de comparaciones no era más de 6n; en 1980 se demostró que no era más de 4n, hasta el resultado de Cole en Sep 1991.

Implementación

C

# include <limits.h>
# include <string.h>
 
# define ALPHABET_SIZE (1 << CHAR_BIT)
 
static void compute_prefix(const char* str, size_t size, int result[size]) {
 size_t q;
 int k;
 result[0] = 0;
 
 k = 0;
 for (q = 1; q < size; q++) {
     while (k > 0 && str[k] != str[q])
         k = result[k-1];
 
     if (str[k] == str[q])
         k++;
     result[q] = k;
 }
}
 
static void prepare_badcharacter_heuristic(const char *str, size_t size,
 int result[ALPHABET_SIZE]) {
 
 size_t i;
 
 for (i = 0; i < ALPHABET_SIZE; i++)
     result[i] = -1;
 
 for (i = 0; i < size; i++)
     result[(size_t) str[i]] = i;
}
 
void prepare_goodsuffix_heuristic(const char *normal, size_t size,
 int result[size + 1]) {
 
 char *left = (char *) normal;
 char *right = left + size;
 char reversed[size+1];
 char *tmp = reversed + size;
 size_t i;
 
 /* reverse string */
 *tmp = 0;
 while (left < right)
     *(--tmp) = *(left++);
 
 int prefix_normal[size];
 int prefix_reversed[size];
 
 compute_prefix(normal, size, prefix_normal);
 compute_prefix(reversed, size, prefix_reversed);
 
 for (i = 0; i <= size; i++) {
     result[i] = size - prefix_normal[size-1];
 }
 
 for (i = 0; i < size; i++) {
     const int j = size - prefix_reversed[i];
     const int k = i - prefix_reversed[i]+1;
 
     if (result[j] > k)
         result[j] = k;
 }
}
/*
 * Boyer-Moore search algorithm
 */
const char *boyermoore_search(const char *haystack, const char *needle) {
 /*
 * Calc string sizes
 */
 size_t needle_len, haystack_len;
 needle_len = strlen(needle);
 haystack_len = strlen(haystack);
 
 /*
 * Simple checks
 */
 if(haystack_len == 0)
     return NULL;
 if(needle_len == 0)
     return NULL;
 if(needle_len > haystack_len)
     return NULL;
 /*
 * Initialize heuristics
 */
 int badcharacter[ALPHABET_SIZE];
 int goodsuffix[needle_len+1];
 
 prepare_badcharacter_heuristic(needle, needle_len, badcharacter);
 prepare_goodsuffix_heuristic(needle, needle_len, goodsuffix);
 
 /*
 * Boyer-Moore search
 */
 size_t s = 0;
 while(s <= (haystack_len - needle_len))
 {
     size_t j = needle_len;
     while(j > 0 && needle[j-1] == haystack[s+j-1])
         j--;
 
     if(j > 0)
     {
         int k = badcharacter[(size_t) haystack[s+j-1]];
         int m;
         if(k < (int)j && (m = j-k-1) > goodsuffix[j])
             s+= m;
         else
             s+= goodsuffix[j];
     }
     else
     {
         return haystack + s;
     }
 }
 
 /* not found */
 return NULL;
}

Variantes

El Algoritmo Boyer-Moore Turbo toma una cantidad constante adicional de espacio para completar una búsqueda en 2n comparaciones (en contra de 3n para Boyer-Moore), donde n es el número de caracteres en el texto para ser buscado.^[5]

El algoritmo Boyer-Moore-Horspool es una simplificación del algoritmo que omite la "tabla primera". El algoritmo Boyer-Moore-Horspool requiere (en el peor caso) mn comparaciones, mientras que el algoritmo Boyer-Moore requiere (en el peor caso) tan solo 3n comparaciones.

Véase también

• Algoritmo Knuth-Morris-Pratt
• Algoritmo Rabin-Karp

Referencias

1. ↑ Hume and Sunday (1991) [Fast String Searching] SOFTWARE—PRACTICE AND EXPERIENCE, VOL. 21(11), 1221–1248 (NOVEMBER 1991)
2. ↑ ^{a b} http://www.movsd.com/bm.htm
3. ↑ R. S. Boyer; J. S. Moore (1977). «A fast string searching algorithm». Comm. ACM 20:  pp. 762–772. doi:10.1145/359842.359859. 
4. ↑ Richard Cole (1991). «Tight bounds on the complexity of the Boyer-Moore algorithm». Proceedings of the 2nd Annual ACM-SIAM Symposium on Discrete Algorithms. pp. 224–233. 
5. ↑ http://www-igm.univ-mlv.fr/~lecroq/string/node15.html

Enlaces externos

• Applet de animación de búsqueda de cadenas
• Artículo original
• Un ejemplo del algoritmo de Boyer-Moore de la página hogar de J Strother Moore, co-inventor del algoritmo
• Una explicación del algoritmo (con código C de ejemplo)
• Cole et al., Límites inferiores más estrechos sobre la complejidad exacta de la coincidencia de cadenas
• Una implementación del algoritmo en Ruby