Saltar al contenido principal
Interactive Algorithm Education

Visualize & Master Algorithms & Data Structures

Explore classic & modern sorting algorithms, efficient searching techniques, and interactive data structure visualizations — all with real-time step-by-step animation, comparisons, swaps, and Big-O metrics.

Search Visualizer

Binary Search

Speed 100ms
Size 15
Difficulty ★★★★★ Beginner
Best For Small or unsorted datasets
Step Progress 0 / 0
Comparisons 0
Target —
Status Ready
Playback Paused
Out of Range
Search Range
Probe / Mid
Found
Step Explanation

Select an algorithm, enter a target value, and click 'Search' to begin.

Pseudocode 
 
 
  
 
 
 When to Use 
 

Select an algorithm to see recommended use cases.

 
 
 
 History 
 

Select an algorithm to see its history.

 
 
 
 
  
 
 
Búsqueda Binaria
  
 
  Elementary (2/5)
 
~30 minutos   Reduce a la mitad en cada paso  Requiere arreglo ordenado  Comparación con el elemento central  O(log n) garantizado  
Prereqs: Arreglos, Notación O grande básica  
 
Quick Reference
Binary Search
Binary Search is an efficient algorithm for finding a target value in a sorted array by repeatedly dividing the search interval in half.

Difficulty: Elementary (2/5)
Stablesearching
Complexity
Best Time
O(1)
Average Time
O(log n)
Worst Time
O(log n)
Space
O(1)
When to Use
When searching in large sorted arrays where O(log n) time complexity is needed and the data is already sorted or can be sorted once.
Pros
  • Extremely efficient O(log n) time complexity
  • Simple to implement and understand
  • Works well on large sorted datasets
Cons
  • Requires the input array to be sorted
  • Not suitable for linked lists (requires random access)
  • More complex than linear search for small arrays
History
Binary Search was first described in 1946 by John Mauchly, though the first known published version of a working binary search algorithm appeared in 1960 in a paper by D. H. Lehmer.
 
 
Búsqueda Binaria encuentra un elemento en un arreglo ordenado en O(log n) dividiendo el espacio de búsqueda por la mitad en cada paso. Es el algoritmo de búsqueda estándar para arreglos ordenados.


Funciona manteniendo dos punteros (low y high) que delimitan la región donde el target puede existir. En cada iteración, compara el target con el elemento central y descarta la mitad que no lo contiene.


Cómo Funciona


    

  1. Inicializa: low = 0, high = n (intervalo [low, high)).
    2. 

  2. Calcula mid = low + (high - low) / 2 (evita overflow).
    3. 

  3. Compara arr[mid] con el target:

      

    • “Si arr[mid] == target: encontrado.”
      • 

    • “Si arr[mid] < target: descarta la mitad izquierda, low = mid + 1.”
      • 

    • “Si arr[mid] > target: descarta la mitad derecha, high = mid.”
      • 

    

    4. 

  4. Repite hasta que low >= high (no encontrado).
    5. 



Idea Clave


El loop invariante es que el target siempre está en el intervalo [low, high) si existe. Cada comparación reduce el intervalo a la mitad, dando log₂ n iteraciones máximo. Por eso necesita el arreglo ordenado: sin orden, no puedes descartar la mitad.


El cálculo de mid es sutil: low + (high - low) / 2 evita overflow cuando low y high son grandes, a diferencia de (low + high) / 2.


Ejemplo Trabajado


Busca target = 7 en [1, 3, 5, 7, 9, 11, 13]:


Iteración 1: low=0, high=7, mid=3


    

  • arr[3] = 7 == target → encontrado en índice 3
    • 



Busca target = 6 en el mismo arreglo:


Iteración 1: low=0, high=7, mid=3


    

  • arr[3] = 7 > 6 → descarta derecha, high = 3
    • 



Iteración 2: low=0, high=3, mid=1


    

  • arr[1] = 3 < 6 → descarta izquierda, low = 2
    • 



Iteración 3: low=2, high=3, mid=2


    

  • arr[2] = 5 < 6 → descarta izquierda, low = 3
    • 



Iteración 4: low=3, high=3 → low >= high → no encontrado


Observa el visualizador mostrar la región de búsqueda encogiendo.


Casos Extremos y Trampas


    

  • Arreglo no ordenado — Búsqueda Binaria retorna resultados incorrectos sin advertencia.
    • 

  • Duplicados — binary_search estándar retorna cualquier ocurrencia. Para el primer/último índice, usa variantes lower_bound/upper_bound.
    • 

  • Overflow en mid — usa low + (high - low) / 2, no (low + high) / 2.
    • 

  • Intervalo vacío — low >= high significa no encontrado; no olvides esta condición de parada.
    • 



Variantes Comunes
































VarianteQué retornaCuándo usar
binary_searchCualquier ocurrenciaSolo existencia
lower_boundPrimer índice ≥ targetRango de valores
upper_boundPrimer índice > targetRango exclusivo
equal_range[lower, upper)Rango completo de duplicados


Aplicaciones


    

  • Búsqueda en arreglos ordenados — arrays, listas estáticas
    • 

  • “Lower/upper bound — APIs de C++ std::lower_bound, Java Collections.binarySearch”
    • 

  • Optimización — muchas soluciones de programación competitiva usan binary search en la respuesta
    • 

  • Debugging — buscar en logs ordenados por timestamp
    • 



Trayectoria de Práctica


    

  1. Implementa Búsqueda Binaria iterativa; prueba en arreglo par e impar.
    2. 

  2. Modifica para retornar el primer índice donde arr[i] >= target (lower_bound).
    3. 

  3. Prueba con todos los elementos iguales: [5, 5, 5, 5, 5] buscando 5.
    4. 

  4. Explica por qué low + (high - low) / 2 es seguro para low=2^30, high=2^30+1.
    5. 

  5. Extiende a búsqueda en floating-point: encuentra la raíz cuadrada de x con precisión 1e-6.
    6.