Cómo Calcular la Complejidad Algorítmica Paso a Paso (con Ejemplos)

Cómo entender y calcular la complejidad algorítmica en tus ejercicios (sin romperte la cabeza)

La guía definitiva para estudiantes que quieren sobrevivir al Big O en clase

¿Te dejaron un reto como: “analiza este algoritmo y calcula su complejidad en notación Big-O”… y no tienes idea por dónde empezar? Respira. Aquí te explicamos cómo entender este tema desde cero, con tips, ejemplos simples y un par de hacks para que no te agarren en curva.

1. Antes de calcular, entiende esto: ¿Qué mide la complejidad?

La complejidad mide cuántos pasos necesita tu código para ejecutarse cuando crece el input. No mide “cuántos segundos tarda”, sino cómo se comporta tu código cuando el tamaño del problema (n) crece.

2. Identifica los bloques del algoritmo

Cuando veas un ejercicio como este:

for i in range(5):
    print("Python es interesante")

for item in items:
    print(item)

for item in items:
    print(item)

Divide y conquista. Pregúntate:

• ¿Qué hace cada bloque?
• ¿Depende del tamaño del input (items) o siempre hace lo mismo?

Tips:

• range(5) → No cambia con el input → constante → O(1)
• for item in items → Depende de n (tamaño del array) → O(n)
• ¿Se repite el loop? Suma su complejidad: O(n) + O(n) = O(2n) → Pero se simplifica como O(n)

3. Asigna "pesos" a cada línea

Este truco lo piden en muchos ejercicios. Es como contar cuántas veces se ejecuta cada instrucción.
Hazlo así:

for i in range(5):       # Ejecuta 5 veces → O(1)
    print(...)           # Se imprime 5 veces

for item in items:       # Se ejecuta n veces → O(n)
    print(...)           # Se imprime n veces

# Igual en el siguiente loop

Hack: Si el número es fijo (como 5, 10, 20), se considera constante = O(1)
Si depende del input (n, len(items), etc.), entonces sí se considera O(n) o más.

4. ¿Hay for dentro de for? Cuidado: eso es multiplicación

Ejemplo típico (como en el Bubble Sort):

for i in range(n):
    for j in range(n):
        # Algo pasa aquí

Esto no se suma, se multiplica: O(n) * O(n) = O(n²)

Pero si están uno después del otro, sí se suman:

for i in range(n):   # O(n)
for j in range(n):   # O(n)

→ Total: O(n + n) = O(2n) → O(n)

5. Elige el término dominante (cuando te dan fórmulas raras)

Cuando te dan esto:

T(n) = 10^2n + 0.01n²

Tienes que pensar: ¿cuál crece más rápido cuando n se vuelve grande?

• n² crece lento comparado con 2ⁿ
• Entonces te quedas con O(2ⁿ)

Regla rápida:

• log(n) < n < n log n < n² < n³ < 2ⁿ < n!

6. Bonus: palabras mágicas para detectar la complejidad

Palabra clave	Significado	Complejidad
range(n)	Bucle lineal	O(n)
range(n-i) o similar	Anidamiento con reducción progresiva	O(n²)
Condicional simple if	Se evalúa rápido	O(1)
print(...), asignaciones	Constante	O(1)
while que depende de n	Puede volverse complejo	O(n) o más
break, return temprano	Optimiza en el mejor caso, pero no afecta el peor caso

7. ¿Y si no sé por dónde empezar? Haz esto:

• Lee el código sin miedo
• Subraya lo que se repite (loops)
• Detecta si hay anidamientos (for dentro de for)
• Cuenta solo lo que cambia con el input
• Simplifica al final con el término más dominante