Escritura a mano juntos! Búsqueda binaria!

Búsqueda binaria, también llamada media búsqueda. Utilizando la idea de la dicotomía, los datos se dividen en dos mitades cada vez que se busca, comenzando por el valor medio.

 

 

Como se muestra en la figura anterior, bajo y alto representan los subíndices en ambos lados de la matriz, y el medio representa el subíndice medio de la matriz.

• Si el valor objetivo es mayor que el valor medio, es decir, el valor objetivo está entre medio y alto, se modifica el valor bajo . Luego compara el valor medio.

• Si el valor objetivo es menor que el valor medio, es decir, el valor objetivo está entre bajo y medio, se modifica el valor alto . Luego compara el valor medio.

Lo anterior es el proceso de búsqueda binaria, cómo encontrar su complejidad temporal ❓

Suponiendo que la longitud de la matriz es n, la longitud se convierte en n / 2 después de buscar una vez, y luego se convierte en n / 4 después de buscar nuevamente, y así sucesivamente. En el peor de los casos, n / 2 ^ k está vacío y la búsqueda se detiene. Entonces tenemos la siguiente fórmula:

n * n / 2 * n / 4 * n / 8 * n / 2 ^ k ·····

Lo anterior es una secuencia de números proporcionales Cuando n / 2 ^ k = 1, k es el número de búsquedas. Es decir, k = log2n, por lo que la complejidad temporal es O (logn), que es un algoritmo muy eficiente. 

Versión no recursiva

función binary_search (arr, key) {
     var low = 0, high = arr.length - 1 ;
    while (bajo <= alto) {
         var mid = parseInt (bajo + (alto - bajo) / 2 ); 
        if (key === arr [mid]) {
             return   mid; 
        } else  if (key> arr [mid]) { 
            low = mid + 1 ; 
        } else  if (clave < arr [mid]) { 
            high = mid -1 ; 
        } else {
             return -1; 
        } 
    } 
}; 
var arr = [5,13,19,21,37,56,64,75,80,88,92 ];
resultado var = binary_search (arr, 21 ); 
console.log (resultado);

Cabe señalar que el valor de mid no debe escribirse como (low + high) / 2, porque si low + high es grande, se desbordará. Por lo tanto, escribir low + (high-low) / 2 no tendrá este problema.

Además, por supuesto, también puede usar la operación de bit para reemplazar low + ((high-low) >> 1) con low + (high-low) / 2, y esta operación de bit es más eficiente.

Versión recursiva

Además del método de bucle descrito anteriormente, la búsqueda binaria también se puede implementar mediante recursividad.

función binary_search (arr, low, high, key) {
     if (low> high) {
         return -1 ; 
    } 
    var mid = low + ((high - low) >> 1 );
    if (arr [mid] == key) {
         return mid; 
    } else  if ( tecla arr [mid]> ) { 
        high = mid - 1 ;
        return binary_search (arr, bajo, alto, clave); 
    } else  if (arr [mid] < key) { 
        low = mid + 1 ;
        regresobinary_search (arr, bajo, alto, clave); 
    } 
}; 
var arr = [5,13,19,21,37,56,64,75,80,88,92 ];
resultado var = binary_search (arr, 0, 11, 21 ); 
console.log (resultado);

3. Hay datos duplicados en la matriz, cómo averiguar dónde apareció el elemento por última vez

La misma idea que la búsqueda binaria presentada anteriormente:

función binary_search (arr, key) {
     var low = 0, high = arr.length - 1 ;
      while (bajo <= alto) {
         var mid = low + ((alto - bajo) >> 1 );
        if ( tecla arr [mid]> ) { 
          high = mid - 1 ; 
        } else  if (arr [mid] < key) { 
          low = mid + 1 ; 
        } else {
           if ((mid == arr.length - 1) || (arr [mid + 1]! = key)) return mid;
          más bajo = medio + 1  ;
        }
    } 
    return -1 ; 
} 
var arr = [5,13,19,21,21,37,56,64,75,80,88,92 ];
resultado var = binary_search (arr, 21 ); 
console.log (resultado);