Si alguna vez te preguntaron «¿cuál es la complejidad de este algoritmo?» y no supiste qué responder, este post es para vos. La complejidad algorítmica Big O mide qué tan bien escala tu código cuando los datos crecen — y una vez que entendés la lógica, empezás a verla en todos los algoritmos que escribís.
→ Si todavía estás aprendiendo algoritmos desde cero, primero leé algoritmos básicos: fundamentos que todo principiante debe dominar.
Qué es la complejidad algorítmica Big O
La complejidad algorítmica Big O es una forma de medir cuánto tiempo o memoria necesita un algoritmo en función del tamaño de la entrada. No mide segundos — los segundos dependen del hardware. Mide cómo crece el tiempo cuando crece la cantidad de datos.
¿Por qué importa? Porque un algoritmo que funciona bien con 100 elementos puede volverse inutilizable con 1.000.000. Entender la complejidad algorítmica Big O te ayuda a elegir la solución correcta antes de que el problema se haga grande.
Notación Big O: cómo leerla sin complicarte
Big O describe el peor caso posible de un algoritmo. Se escribe O(algo), donde «algo» describe cómo crece el tiempo según el tamaño de la entrada (n).
Leéla así: «a medida que n crece, el tiempo crece como…»
| Notación | Nombre | Qué significa |
|---|---|---|
| O(1) | Constante | Siempre tarda lo mismo, sin importar n |
| O(log n) | Logarítmica | Crece muy lento (ej: búsqueda binaria) |
| O(n) | Lineal | Crece proporcional a n |
| O(n log n) | Lineal logarítmica | Un poco más que lineal (ej: merge sort) |
| O(n²) | Cuadrática | Crece rápido — dos loops anidados |
| O(2ⁿ) | Exponencial | Crece explosivamente — evitar siempre |
Complejidad algorítmica Big O con ejemplos en Python
O(1) — Constante
python
def primero(lista):
return lista[0]Siempre accedés al primer elemento sin importar el tamaño de la lista. El tiempo no cambia.
O(n) — Lineal
python
def buscar(lista, objetivo):
for elemento in lista:
if elemento == objetivo:
return True
return FalseEn el peor caso revisás todos los elementos. Si la lista se duplica, el tiempo se duplica.
O(n²) — Cuadrática
python
def tiene_duplicados(lista):
for i in range(len(lista)):
for j in range(i + 1, len(lista)):
if lista[i] == lista[j]:
return True
return FalseDos loops anidados que dependen del tamaño de la lista. Si n se duplica, el tiempo se cuadruplica. Para listas grandes, esto se vuelve muy lento muy rápido.
O(log n) — Logarítmica
La búsqueda binaria. Cada paso descarta la mitad de los elementos. Con 1.000.000 de elementos, necesitás a lo sumo 20 pasos. Podés ver la implementación completa en búsqueda binaria en Python: cómo funciona y cuándo usarla.
Cómo identificar la complejidad algorítmica Big O en tu propio código
Una vez que aprendés los patrones, es automático:
- Un loop simple sobre
nelementos → O(n) - Dos loops anidados sobre
n→ O(n²) - Acceder por índice o clave de diccionario → O(1)
- Dividir el problema a la mitad en cada paso → O(log n)
El truco es preguntarte: «si n se hace 10 veces más grande, ¿cuánto más tarda mi código?»
¿Necesitás dominar la complejidad algorítmica Big O para tu primer trabajo?
No necesitás ser experto en análisis de algoritmos para conseguir tu primer empleo. Pero sí deberías poder:
- Reconocer un O(n²) cuando lo ves (dos loops anidados)
- Saber que acceder a un diccionario por clave es O(1)
- Entender por qué la búsqueda binaria es mejor que la lineal para listas grandes
- No entrar en pánico cuando te pregunten «¿cuál es la complejidad de esto?» en una entrevista
Si estás preparándote para entrevistas, también leé cómo prepararte para una entrevista técnica siendo programador junior.
Seguí practicando en el campus
La complejidad algorítmica Big O se entiende mejor practicando que leyendo. En el campus de Academia MC tenés ejercicios de algoritmos donde podés aplicar este conocimiento — sin costo, con desafíos reales y comunidad para resolver dudas. Entrá en campus.marianacasella.com.
Deja una respuesta