Algoritmo de Búsqueda Binaria: Guía Completa con Ejemplos y Análisis

Fundamentos de la búsqueda binaria

Definición y principios básicos

El algoritmo de búsqueda binaria es una de las técnicas más elegantes y eficientes en las ciencias de la computación para localizar un valor específico dentro de una colección de datos ordenada. En lugar de examinar cada elemento uno por uno, la búsqueda binaria divide repetidamente el espacio de búsqueda a la mitad, estrechando el cerco sobre el objetivo con una rapidez asombrosa. Esta filosofía de «divide y vencerás» es lo que diferencia a la búsqueda binaria de los enfoques de fuerza bruta, y constituye la base de gran parte del software eficiente actual. Donald Knuth, en su obra fundamental The Art of Computer Programming (1968), describió la búsqueda binaria como algo engañosamente simple de enunciar, pero sorprendentemente difícil de implementar correctamente, una caracterización que ha resistido el paso del tiempo.

En su esencia, el algoritmo funciona manteniendo dos punteros —un índice low (bajo) y un índice high (alto)— que definen la región de búsqueda actual dentro del array. En cada iteración, calcula el punto medio de esta región y compara el elemento de dicho punto medio con el valor objetivo. Si el elemento central coincide con el objetivo, la búsqueda finaliza. Si el objetivo es menor que el elemento central, el algoritmo descarta la mitad derecha de la región de búsqueda; si es mayor, descarta la mitad izquierda. Esta reducción sistemática a la mitad continúa hasta que se encuentra el objetivo o hasta que la región de búsqueda se colapsa, lo que indica que el valor no está presente en el array.

La potencia de este enfoque se hace evidente al considerar la escala en la que opera. Un array ordenado de mil millones de elementos requiere, como máximo, 30 comparaciones para localizar cualquier valor mediante búsqueda binaria, ya que log₂(1.000.000.000) ≈ 30. Este es un resultado profundo: el número de operaciones necesarias crece solo logarítmicamente con el tamaño de la entrada, lo que hace que la búsqueda binaria sea práctica incluso para conjuntos de datos masivos donde un escaneo lineal sería prohibitivamente lento. Esta tasa de crecimiento logarítmico sitúa a la búsqueda binaria en la categoría de algoritmos que escalan con elegancia, una propiedad que los ingenieros valoran enormemente en los sistemas de producción.

Prerrequisitos: solo para arrays ordenados

La búsqueda binaria conlleva un prerrequisito innegociable: los datos deben estar ordenados de forma consistente, ya sea ascendente o descendentemente, antes de que el algoritmo pueda funcionar correctamente. Esta restricción no es una nota al pie menor; es la premisa fundamental que valida toda la estrategia de división. Cuando se descarta la mitad izquierda del espacio de búsqueda porque el objetivo es mayor que el punto medio, se confía implícitamente en que todos los elementos a la izquierda son menores. Si el array no estuviera ordenado, esa suposición fallaría y el algoritmo devolvería silenciosamente resultados incorrectos sin ninguna alerta de error. Este es uno de los orígenes más comunes de errores cuando los desarrolladores implementan la búsqueda binaria por primera vez.

En la práctica, el requisito de ordenación significa que la búsqueda binaria es más adecuada para conjuntos de datos estáticos o que se modifican con poca frecuencia, donde una ordenación inicial compensa las múltiples búsquedas posteriores. Ordenar un array de n elementos suele costar un tiempo de O(n log n) —por ejemplo, utilizando merge sort o Timsort—, por lo que si solo se necesita realizar una búsqueda, un simple escaneo lineal de O(n) puede resultar más económico en términos globales. Sin embargo, cuando es necesario realizar cientos o miles de búsquedas sobre los mismos datos, el coste inicial de la ordenación se amortiza rápidamente y la búsqueda binaria se convierte en la ganadora indiscutible. Estructuras de índices de bases de datos como los árboles B, los árboles binarios de búsqueda y los índices invertidos ordenados explotan este mismo principio a escala arquitectónica.

Cómo funciona la búsqueda binaria

El proceso del algoritmo paso a paso

Analizar el algoritmo de búsqueda binaria paso a paso revela cuán sistemática y limpia es su lógica. El proceso comienza estableciendo low = 0 y high = n - 1, donde n es el número de elementos en el array. Estas dos variables definen la ventana de búsqueda activa. El algoritmo entra entonces en un bucle que continúa mientras low sea menor o igual que high, lo que significa que todavía queda al menos un elemento por examinar. Esta condición del bucle es crítica: usar un «estrictamente menor que» en lugar de «menor o igual que» haría que el algoritmo omitiera el último elemento candidato restante, un sutil error de tipo off-by-one que ha confundido incluso a programadores experimentados.

Dentro de cada iteración del bucle, el algoritmo calcula el índice del punto medio y recupera el elemento en esa posición. Existen tres resultados posibles: el elemento es igual al objetivo (éxito: se devuelve el índice), el elemento es menor que el objetivo (se mueve low a mid + 1, desplazando la ventana a la derecha) o el elemento es mayor que el objetivo (se mueve high a mid - 1, desplazando la ventana a la izquierda). Cada uno de estos resultados termina la búsqueda o reduce el espacio de búsqueda aproximadamente a la mitad. Si el bucle termina sin encontrar el objetivo —lo que significa que low ha superado a high—, el algoritmo devuelve un valor centinela, comúnmente -1, para indicar que el objetivo no está presente en el array.

Técnica de cálculo del punto medio

El cálculo del punto medio merece especial atención porque la formulación ingenua contiene un error sutil pero grave. La fórmula intuitiva mid = (low + high) / 2 parece correcta, pero puede provocar un desbordamiento de enteros (integer overflow) en lenguajes como C, C++ y Java cuando tanto low como high son enteros grandes; específicamente, cuando su suma supera el valor máximo representable por un entero de 32 bits (2.147.483.647). Este fallo pasó desapercibido en la implementación de la biblioteca estándar de Java durante casi una década antes de que Joshua Bloch lo documentara en una famosa entrada de blog en 2006. La solución es calcular el punto medio como mid = low + (high - low) / 2, que es matemáticamente equivalente pero evita el desbordamiento al no sumar nunca ambos índices.

En Python, el desbordamiento de enteros no es una preocupación porque el lenguaje utiliza enteros de precisión arbitraria, pero la fórmula corregida sigue siendo la opción idiomática en la mayoría de los contextos educativos y profesionales porque demuestra consciencia sobre el problema del desbordamiento. En lenguajes de nivel inferior, algunos desarrolladores prefieren la variante bit a bit mid = (low + high) >>> 1 (en Java), que utiliza un desplazamiento a la derecha sin signo para gestionar correctamente el bit de acarreo. Comprender estos matices es lo que distingue a un programador que ha estudiado los algoritmos en profundidad de uno que solo los conoce superficialmente. El cálculo del punto medio es un pequeño detalle con grandes consecuencias, e ilustra un tema recurrente en la implementación de algoritmos: el diablo está en los detalles de las condiciones de contorno.

Lógica de decisión de la ruta de búsqueda

La lógica de decisión tras cada comparación en el punto medio es lo que impulsa la convergencia del algoritmo. Cuando el algoritmo mueve low a mid + 1, está afirmando que el objetivo —si existe— debe estar estrictamente a la derecha de mid en el array. Del mismo modo, establecer high en mid - 1 afirma que el objetivo debe estar estrictamente a la izquierda. Los ajustes de +1 y -1 son esenciales porque garantizan que el propio punto medio sea excluido de la siguiente ventana de búsqueda; sin ellos, el algoritmo podría quedar atrapado en un bucle infinito examinando el mismo punto medio repetidamente cuando la ventana de búsqueda contiene exactamente dos elementos. Este control minucioso es lo que garantiza que el algoritmo siempre progrese y termine en un tiempo finito.

Ejemplo paso a paso de búsqueda binaria

Ejemplo manual con números

Consideremos un array ordenado: [2, 5, 8, 12, 16, 23, 38, 45, 56, 72, 91], que contiene 11 elementos indexados del 0 al 10. Supongamos que el objetivo es 23. Inicialmente, low = 0 y high = 10, por lo que el punto medio es mid = 0 + (10 - 0) / 2 = 5. El elemento en el índice 5 es 23, una coincidencia inmediata en la primera comparación. Este escenario ideal, aunque satisfactorio, no es representativo; en la práctica, el objetivo rara vez se encuentra en el punto medio exacto y suelen ser necesarias varias rondas de eliminación.

Supongamos ahora que el objetivo es 56. En la primera iteración, mid = 5 y array[5] = 23. Como 56 > 23, el algoritmo establece low = 6, descartando toda la mitad izquierda. En la segunda iteración, la ventana de búsqueda abarca los índices del 6 al 10, lo que resulta en mid = 6 + (10 - 6) / 2 = 8 y array[8] = 56. El objetivo se encuentra en solo dos comparaciones en un array de once elementos, una demostración vívida de lo rápido que la búsqueda binaria estrecha el rango de candidatos. Incluso si el array tuviera 10.000 elementos, la búsqueda terminaría en un máximo de 14 comparaciones.

Gestión de casos límite

Los casos límite revelan la robustez de una implementación de búsqueda binaria. Buscar un valor menor que el elemento más pequeño del array hace que high se reduzca por debajo de low tras unas pocas iteraciones, y el bucle termina correctamente devolviendo «no encontrado». Buscar un valor mayor que el elemento más grande presenta un comportamiento simétrico: low sube por encima de high. Buscar en un array de un solo elemento también es sencillo: la única comparación coincide o provoca que uno de los punteros cruce al otro, terminando el algoritmo tras un paso. El único caso límite que requiere un manejo explícito antes de ejecutar el algoritmo es un array vacío, donde high se inicializaría como -1 (ya que n - 1 = -1 para n = 0), haciendo que la condición del bucle sea falsa de inmediato y devolviendo «no encontrado» sin realizar comparaciones.

Los elementos duplicados introducen un matiz interesante: el algoritmo de búsqueda binaria estándar encontrará alguna instancia del objetivo, pero no necesariamente la primera ni la última. Si el requisito es encontrar la ocurrencia más a la izquierda o más a la derecha de un valor —una necesidad común cuando se trabaja con arrays ordenados que permiten entradas repetidas—, debe utilizarse una versión modificada del algoritmo. Estas variantes, a veces llamadas búsquedas de límite inferior (lower bound) y límite superior (upper bound) (emulando las funciones de la STL de C++ std::lower_bound y std::upper_bound), ajustan la lógica de decisión para seguir buscando incluso después de encontrar una coincidencia, convergiendo en la ocurrencia del límite. Vale la pena comprender esta extensión, ya que aparece con frecuencia en programación competitiva y problemas de consultas basados en intervalos.

Complejidad temporal de la búsqueda binaria

Desglose de la notación Big O

La complejidad temporal del algoritmo de búsqueda binaria es O(log n), donde n es el número de elementos en el array. Para entender por qué, consideremos que cada comparación reduce el espacio de búsqueda a la mitad. Empezando con n elementos, tras una comparación quedan como máximo n/2 candidatos, tras dos quedan n/4, y tras k comparaciones quedan n / 2^k candidatos. El algoritmo termina cuando el espacio de búsqueda alcanza el tamaño 1, lo que ocurre cuando n / 2^k = 1, es decir, k = log₂(n). Por lo tanto, el número máximo de comparaciones es:

$$k=\lfloor {\log }_2(n)\rfloor +1$$

Este crecimiento logarítmico es lo que hace que la búsqueda binaria sea tan potente a gran escala. Para un conjunto de datos de tamaño n = 1.024, el peor caso requiere 10 comparaciones. Para n = 1.048.576 (un millón), requiere 20 comparaciones. Para n = 1.073.741.824 (mil millones), solo bastan 30 comparaciones. La brecha entre O(log n) y O(n) no es meramente teórica; se traduce directamente en diferencias de órdenes de magnitud en el tiempo de ejecución para arrays grandes. En un mundo donde los arrays contienen habitualmente millones de registros, esta distinción es operativamente significativa.

Casos mejor, promedio y peor

El mejor caso para la búsqueda binaria ocurre cuando el objetivo se encuentra en el punto medio del array inicial, lo que resulta en una sola comparación y un tiempo O(1). Esto sucede, por ejemplo, al buscar el valor de la mediana en un array ordenado. El peor caso ocurre cuando el objetivo no está presente en el array o cuando se encuentra en uno de los extremos, lo que obliga a reducir el espacio de búsqueda a la mitad hasta llegar a un solo elemento antes de concluir, con un coste de O(log n) comparaciones. El caso promedio también es O(log n), porque incluso en escenarios típicos de objetivos aleatorios, el número esperado de comparaciones es proporcional al logaritmo del tamaño del array. A diferencia de algunos algoritmos donde el caso promedio es drásticamente mejor que el peor caso, en la búsqueda binaria ambos están relativamente cerca, lo cual es una propiedad deseable para sistemas que requieren un rendimiento predecible.

Detalles de la complejidad espacial

La versión iterativa de la búsqueda binaria utiliza un espacio auxiliar de O(1): mantiene solo un número fijo de variables (low, high, mid) independientemente del tamaño de la entrada, lo que la hace excepcionalmente eficiente en memoria. La versión recursiva, por el contrario, utiliza un espacio de pila de O(log n), ya que cada llamada recursiva añade un nuevo marco a la pila de llamadas, y la profundidad máxima de la recursión es log₂(n). Para la mayoría de las entradas prácticas, esta diferencia es insignificante —30 marcos de pila para log₂(10^9) ≈ 30 es algo trivial—. Sin embargo, en sistemas profundamente embebidos con memoria de pila muy limitada, o en entornos donde el desbordamiento de pila es una preocupación real, el enfoque iterativo es la opción más segura y convencional. Por esta razón, la mayoría de las implementaciones de bibliotecas estándar, como el módulo bisect de Python y Arrays.binarySearch de Java, utilizan la forma iterativa.

Implementación iterativa de la búsqueda binaria

Estructura del pseudocódigo

Antes de pasar al código real, el pseudocódigo proporciona un esquema agnóstico del lenguaje que aisla la lógica del algoritmo del ruido sintáctico. El pseudocódigo de la búsqueda binaria iterativa es claro: inicializar low a 0 y high al último índice; luego, iterar mientras low ≤ high. Calcular mid, comparar array[mid] con el objetivo y actualizar low o high en consecuencia, o devolver mid si hay coincidencia. Si el bucle termina sin coincidencia, devolver -1. Este pseudocódigo se traduce casi directamente a cualquier lenguaje imperativo, lo que convierte a la búsqueda binaria en un ejemplo educativo excelente: el algoritmo y su implementación están inusualmente próximos.

Ejemplo de código en Python

La siguiente implementación en Python sigue el patrón iterativo con precisión, utilizando la fórmula del punto medio a prueba de desbordamientos. Acepta una lista ordenada y un valor objetivo, devolviendo el índice del objetivo si se encuentra o -1 si está ausente.

def binary_search(arr, target):
    """
    Iterative binary search.
    Returns the index of target in arr if found, otherwise -1.
    Assumes arr is sorted in ascending order.
    """
    low = 0
    high = len(arr) - 1

    while low <= high:
        mid = low + (high - low) // 2  # Overflow-safe midpoint

        if arr[mid] == target:
            return mid          # Target found at index mid
        elif arr[mid] < target:
            low = mid + 1       # Discard left half
        else:
            high = mid - 1      # Discard right half

    return -1  # Target not present in array


# Example usage
sorted_array = [2, 5, 8, 12, 16, 23, 38, 45, 56, 72, 91]

print(binary_search(sorted_array, 23))   # Output: 5
print(binary_search(sorted_array, 56))   # Output: 8
print(binary_search(sorted_array, 99))   # Output: -1
print(binary_search(sorted_array, 2))    # Output: 0
print(binary_search(sorted_array, 91))   # Output: 10

Análisis de la eficiencia del bucle

La implementación iterativa es esbelta y directa. Cada iteración del bucle while realiza exactamente una comparación contra el objetivo, además de la aritmética de punteros para actualizar low o high. Todas estas operaciones son de tiempo constante, por lo que el coste total del bucle es proporcional al número de iteraciones, que está acotado por ⌊log₂(n)⌋ + 1. No hay sobrecarga por la configuración de llamadas a funciones, ni riesgo de desbordamiento de pila, ni asignación de memoria más allá de unas pocas variables enteras. En aplicaciones críticas para el rendimiento —por ejemplo, una función de búsqueda llamada millones de veces por segundo en un sistema de trading o un motor de consultas de base de datos— esta concisión del bucle interno es fundamental. Muchos procesadores modernos también pueden optimizarlo agresivamente: el cuerpo del bucle es pequeño, con ramificaciones predecibles para la mayoría de las cargas de trabajo y amigable con la caché, ya que acceder a elementos del array por índice es un cálculo de dirección simple.

El módulo integrado bisect de Python, parte de la biblioteca estándar desde Python 2, proporciona una implementación de búsqueda binaria altamente optimizada escrita en C. La función bisect.bisect_left devuelve el punto de inserción más a la izquierda para un valor objetivo, realizando efectivamente una búsqueda de límite inferior. Para código Python en producción, bisect es casi siempre preferible a una implementación personalizada porque es más rápido, está probado y es inmediatamente reconocible para otros programadores de Python. Comprender cómo escribir una búsqueda binaria desde cero sigue siendo esencial para entrevistas y trabajos de bajo nivel, pero reconocer cuándo usar una implementación de biblioteca consolidada es igualmente parte del desarrollo de software profesional.

Implementación recursiva de la búsqueda binaria

Lógica de la función recursiva

La formulación recursiva de la búsqueda binaria expresa la naturaleza de «divide y vencerás» del algoritmo de forma más explícita que la versión iterativa, a costa de la sobrecarga de la pila de llamadas. La función toma el array, el objetivo y los límites actuales low y high como parámetros. El caso base ocurre cuando low > high, lo que significa que el espacio de búsqueda está vacío y el objetivo no está presente; la función devuelve -1. El caso recursivo calcula el punto medio, comprueba si hay coincidencia y luego se llama a sí mismo sobre el subarray izquierdo o derecho dependiendo del resultado de la comparación. Cada llamada recursiva reduce el tamaño del problema aproximadamente a la mitad, garantizando que la recursión termine tras un máximo de log₂(n) niveles.

Una decisión de diseño importante en la versión recursiva es si pasar el subarray real (una nueva porción de la lista) o pasar los límites de los índices sobre el array original. Pasar porciones (slices) es más sencillo de leer, pero crea nuevos objetos de lista en cada nivel de recursión, elevando la complejidad espacial a O(n), un coste innecesario. Pasar los límites de los índices evita cualquier asignación de memoria y mantiene la complejidad espacial en O(log n) solo para la pila de llamadas. El enfoque de límites de índices es el estándar en la práctica, aunque haga que la firma de la función sea ligeramente más compleja, porque respeta el principio de que el algoritmo no debe pagar por memoria que no necesita.

Código en Python

La siguiente implementación en Python utiliza el enfoque de límites de índices, haciendo explícita la estructura recursiva al tiempo que evita la asignación innecesaria de memoria.

def binary_search_recursive(arr, target, low, high):
    """
    Recursive binary search.
    Returns the index of target in arr if found, otherwise -1.
    Initial call: binary_search_recursive(arr, target, 0, len(arr) - 1)
    """
    # Base case: search space is empty
    if low > high:
        return -1

    mid = low + (high - low) // 2  # Overflow-safe midpoint

    if arr[mid] == target:
        return mid                              # Target found
    elif arr[mid] < target:
        return binary_search_recursive(arr, target, mid + 1, high)  # Search right half
    else:
        return binary_search_recursive(arr, target, low, mid - 1)   # Search left half


# Convenience wrapper so callers don't need to pass initial bounds
def binary_search(arr, target):
    return binary_search_recursive(arr, target, 0, len(arr) - 1)


# Example usage
sorted_array = [2, 5, 8, 12, 16, 23, 38, 45, 56, 72, 91]

print(binary_search(sorted_array, 23))   # Output: 5
print(binary_search(sorted_array, 56))   # Output: 8
print(binary_search(sorted_array, 99))   # Output: -1

Consideraciones sobre la profundidad de recursión

Python impone un límite de recursión por defecto de 1.000 niveles (ajustable mediante sys.setrecursionlimit), lo que significa que la función de búsqueda binaria recursiva fallaría con un RecursionError para cualquier array con más de aproximadamente 2^999 elementos, un número tan astronómicamente grande que nunca aparecerá en la práctica. Específicamente para Python, la profundidad de recursión no es una preocupación práctica para la búsqueda binaria. Sin embargo, en lenguajes sin optimización de llamada de cola (tail-call optimization), la versión recursiva sí incurre en una sobrecarga medible en comparación con la versión iterativa: cada llamada a la función requiere configurar un nuevo marco de pila, pasar argumentos y desmontar el marco al retornar. En lenguajes como Scheme o Haskell, que sí admiten la optimización de llamada de cola, las versiones recursiva e iterativa se compilan en código de máquina esencialmente equivalente, por lo que la elección es puramente estilística.

La implementación recursiva suele preferirse en entornos académicos porque refleja la definición matemática de la búsqueda binaria como una relación de recurrencia: T(n) = T(n/2) + O(1), con el caso base T(1) = O(1). Resolver esta recurrencia mediante el Teorema Maestro produce inmediatamente T(n) = O(log n), proporcionando una prueba formal de la complejidad del algoritmo. Esta conexión entre el código recursivo y las relaciones de recurrencia es una de las razones por las que los planes de estudio de informática enfatizan el pensamiento recursivo: une el código limpio con el análisis riguroso de una manera que el código iterativo no suele permitir.

Búsqueda binaria frente a búsqueda lineal

Comparativa de diferencias clave

La búsqueda lineal, también llamada búsqueda secuencial, escanea un array elemento por elemento desde el principio hasta que encuentra el objetivo o agota el array. No requiere preprocesamiento —el array puede estar en cualquier orden— y su implementación es trivialmente sencilla. La búsqueda binaria, por el contrario, exige un array ordenado pero compensa esa restricción con búsquedas drásticamente más rápidas. Para arrays pequeños (normalmente menos de 10 o 20 elementos), la diferencia es insignificante, y la búsqueda lineal puede ser incluso más rápida en la práctica debido a su lógica más simple y mejor comportamiento de caché en datos diminutos. Sin embargo, a medida que los arrays crecen hasta miles o millones de elementos, la brecha entre O(n) y O(log n) se vuelve profunda y prácticamente decisiva.

Otra distinción importante es la adaptabilidad. La búsqueda lineal funciona en cualquier estructura de datos que admita acceso secuencial —arrays, listas enlazadas, flujos de datos (streams), generadores—, mientras que la búsqueda binaria requiere acceso aleatorio (la capacidad de saltar directamente al índice mid en un tiempo O(1)). Esto hace que la búsqueda binaria esté intrínsecamente ligada a estructuras de tipo array y no sea adecuada para listas enlazadas sin modificaciones. Además, si el conjunto de datos cambia con frecuencia —si se insertan o eliminan elementos regularmente—, mantener el orden requerido por la búsqueda binaria introduce una sobrecarga considerable. En tales escenarios dinámicos, los árboles binarios de búsqueda equilibrados (como los árboles AVL o los árboles rojo-negro) o las skip lists proporcionan una búsqueda de O(log n) al tiempo que admiten actualizaciones eficientes, ofreciendo lo mejor de ambos mundos.

Tabla de métricas de rendimiento

La siguiente tabla resume las características clave de rendimiento y usabilidad de la búsqueda binaria frente a la búsqueda lineal en las dimensiones más importantes.

Característica	Búsqueda binaria	Búsqueda lineal
Complejidad temporal (Mejor caso)	O(1)	O(1)
Complejidad temporal (Caso promedio)	O(log n)	O(n)
Complejidad temporal (Peor caso)	O(log n)	O(n)
Complejidad espacial (Iterativa)	O(1)	O(1)
Complejidad espacial (Recursiva)	O(log n)	O(n)
Prerrequisito	Requiere array ordenado	Ninguno: funciona con datos desordenados
Requisito de estructura de datos	Acceso aleatorio (array)	Acceso secuencial suficiente
Complejidad de implementación	Moderada (requiere lógica de límites)	Trivial
Comparaciones para n = 1.000.000	~20	Hasta 1.000.000
¿Adecuado para datos dinámicos?	No (requiere reordenar al actualizar)	Sí

Elegir el método adecuado

La elección entre la búsqueda binaria y la búsqueda lineal es, en última instancia, una cuestión de contexto y restricciones. Cuando los datos ya están ordenados —o cuando se ordenan una vez para buscarlos muchas veces—, la búsqueda binaria es casi universalmente la elección correcta para arrays de tamaño no trivial. La regla general entre profesionales es que una vez que un array supera los 50 elementos aproximadamente y se busca repetidamente, el argumento a favor de la búsqueda binaria es indiscutible solo por motivos de rendimiento. Para búsquedas puntuales en arrays pequeños, la simplicidad de la búsqueda lineal y su independencia de los requisitos de ordenación la hacen totalmente apropiada, y ningún ingeniero debería sentirse obligado a ordenar datos solo para usar un algoritmo más sofisticado.

En los sistemas del mundo real, la búsqueda binaria no aparece solo como una función independiente, sino como una pieza conceptual básica. Los motores de bases de datos utilizan la búsqueda binaria en páginas de índices ordenados para localizar filas en O(log n) lecturas de disco. El comando git bisect utiliza la búsqueda binaria a través del historial de commits para identificar qué cambio introdujo un error, una aplicación bellamente práctica de la misma lógica de división. El control de versiones, las búsquedas de DNS, los sistemas de autocompletado y las tablas de enrutamiento IP explotan datos ordenados y estrategias de búsqueda binaria o logarítmica en su núcleo. Comprender profundamente el algoritmo de búsqueda binaria —no solo su código, sino su lógica, sus limitaciones y sus garantías de complejidad— no es, por tanto, un ejercicio académico. Es un conocimiento fundamental para cualquiera que diseñe o analice software a escala.