Inicio

Big O Complexity Visualizer

Visualiza y compara complejidades algorítmicas en tiempo real

Compara cómo crece el tiempo de ejecución según el tamaño de entrada (n). Desliza para ver el impacto a escala.

1 50 100 150 200

Gráfica Comparativa

Operaciones para n = 100

Complejidad Operaciones Tiempo Estimado* Ejemplos

*Asumiendo 1 operación = 1 nanosegundo

Ejemplos de Algoritmos

O(1) Excelente

Constante

  • Acceso a array por índice: arr[5]
  • Inserción en hash table
  • Push/Pop en stack
  • Operaciones aritméticas básicas

El tiempo es siempre el mismo, sin importar el tamaño de entrada.

O(log n) Muy Bueno

Logarítmica

  • Búsqueda binaria
  • Operaciones en árboles balanceados (AVL, Red-Black)
  • Skip lists
  • Búsqueda en heap

Divide el problema a la mitad en cada paso. Muy eficiente.

O(n) Bueno

Lineal

  • Recorrer un array: for (let i = 0; i < n; i++)
  • Búsqueda lineal
  • Encontrar el mínimo/máximo
  • Copiar un array

El tiempo crece proporcionalmente al tamaño de entrada.

O(n log n) Aceptable

Lineal-Logarítmica

  • Merge Sort
  • Quick Sort (promedio)
  • Heap Sort
  • Divide y conquistarás eficiente

Algoritmos de ordenamiento eficientes. El mejor caso general.

O(n²) Cuidado

Cuadrática

  • Bubble Sort
  • Selection Sort
  • Insertion Sort
  • Dos loops anidados sobre n

Evitar con grandes datasets. OK para n pequeño (~100).

O(2ⁿ) Peligroso

Exponencial

  • Fibonacci recursivo sin memoization
  • Subconjuntos de un conjunto (power set)
  • Torres de Hanoi
  • Backtracking sin poda

Prácticamente imposible para n > 30. Requiere optimización.

Tips para Optimizar tu Código

💡

Usa estructuras de datos apropiadas

Un HashMap puede convertir O(n) en O(1) para búsquedas. Los sets son perfectos para verificar existencia.

🔍

Evita loops anidados innecesarios

Dos loops de O(n) son mejor que uno de O(n²). Considera usar hash maps para eliminar el segundo loop.

⚡

Aprende divide y conquistarás

Dividir el problema a la mitad (O(log n)) es muchísimo mejor que revisar todo (O(n)).

📊

Memoization para recursión

Guarda resultados calculados previamente. Puede convertir O(2ⁿ) en O(n).

🎯

El mejor algoritmo depende del contexto

Para n pequeño (~10), O(n²) puede ser más rápido que O(n log n) por el overhead.

⏱️

Mide en tu caso real

Big O es teórico. Siempre haz benchmarks con tus datos reales para confirmar.