Analiza la complejidad temporal y espacial de tu código. Pega Python, JavaScript, Java, C++, C# o Go y observa la derivación bucle por bucle.
Pega una función completa para obtener la mejor lectura. Los comentarios y las cadenas de texto se ignoran, así que un bucle escrito dentro de una cadena no se contará.
Opcional. Cronometra un bucle simple en la máquina donde vaya a ejecutarse y divide sus iteraciones entre los segundos que tardó: no publicamos ninguna cifra sobre la velocidad de un ordenador. Si lo dejas en blanco, el análisis no cambia.
Las ocho clases en las que encaja casi cualquier algoritmo.
| Notación | Nombre | Crecimiento | Límite práctico |
|---|---|---|---|
| O(1) | Constante | Sin crecimiento | Sin límite |
| O(log n) | Logarítmica | +1 paso cada vez que n se duplica | Miles de millones |
| O(n) | Lineal | 2x entrada, 2x tiempo | Decenas de millones |
| O(n log n) | Linealítmica | Algo más pronunciada que la lineal | Millones |
| O(n²) | Cuadrática | 2x entrada, 4x tiempo | Decenas de miles |
| O(n³) | Cúbica | 2x entrada, 8x tiempo | Cientos |
| O(2^n) | Exponencial | +1 elemento, 2x tiempo | Unos 30–40 |
| O(n!) | Factorial | +1 elemento, (n+1)x tiempo | Unos 10–12 |
Coste en el caso promedio por operación, con el espacio que ocupa la propia estructura.
| Estructura | Acceso | Búsqueda | Inserción | Borrado | Espacio |
|---|---|---|---|---|---|
| Arreglo | O(1) | O(n) | O(n) | O(n) | O(n) |
| Lista enlazada | O(n) | O(n) | O(1) | O(1) | O(n) |
| Pila | O(n) | O(n) | O(1) | O(1) | O(n) |
| Cola | O(n) | O(n) | O(1) | O(1) | O(n) |
| Tabla hash | N/A | O(1) | O(1) | O(1) | O(n) |
| Árbol binario de búsqueda | O(log n) | O(log n) | O(log n) | O(log n) | O(n) |
| Árbol AVL | O(log n) | O(log n) | O(log n) | O(log n) | O(n) |
| Árbol rojo-negro | O(log n) | O(log n) | O(log n) | O(log n) | O(n) |
| Árbol B | O(log n) | O(log n) | O(log n) | O(log n) | O(n) |
| Montículo | N/A | O(n) | O(1) | O(log n) | O(n) |
Tiempo en el mejor caso, el promedio y el peor, el espacio adicional necesario, y si los elementos iguales conservan su orden original.
| Algoritmo | Mejor | Promedio | Peor | Espacio | Estable |
|---|---|---|---|---|---|
| Quicksort | O(n log n) | O(n log n) | O(n²) | O(log n) | No |
| Ordenación por mezcla | O(n log n) | O(n log n) | O(n log n) | O(n) | Sí |
| Heapsort | O(n log n) | O(n log n) | O(n log n) | O(1) | No |
| Timsort | O(n) | O(n log n) | O(n log n) | O(n) | Sí |
| Ordenación de burbuja | O(n) | O(n²) | O(n²) | O(1) | Sí |
| Ordenación por inserción | O(n) | O(n²) | O(n²) | O(1) | Sí |
| Ordenación por selección | O(n²) | O(n²) | O(n²) | O(1) | No |
| Ordenación radix | O(nk) | O(nk) | O(nk) | O(n + k) | Sí |
| Ordenación por conteo | O(n + k) | O(n + k) | O(n + k) | O(k) | Sí |
| Ordenación por cubetas | O(n + k) | O(n + k) | O(n²) | O(n) | Sí |
Este analizador lee la estructura del código: anidamiento de bucles, forma del paso de cada bucle, tipo de recursión, costes conocidos de biblioteca y asignaciones de memoria. No puede ver el comportamiento que depende de los datos, el interior de las bibliotecas, ni la lógica que altera el número de iteraciones en tiempo de ejecución. Toma el resultado como una lectura bien fundamentada del código que pegaste, y contrasta la derivación con tu propio criterio.
También podrías encontrar útiles estas calculadoras
Pega tu código y obtén su complejidad ciclomática por función
Memoria de un array y cómo leer su longitud
Cobertura por criterio, comparada con requisitos que sí podemos citar
Cuenta SLOC, comentarios y líneas en blanco y estima el esfuerzo
Pega una función y esta calculadora lee su estructura: cómo se anidan los bucles, cómo avanza cada uno, cómo una llamada recursiva reduce su argumento, qué llamadas de biblioteca esconden un recorrido completo, e informa tanto de la complejidad temporal como de la espacial. Cada conclusión aparece junto a la línea que la produjo, para que puedas comprobar el razonamiento en lugar de fiarte de una notación. No se sube nada: el análisis se ejecuta por completo en tu navegador.
Big-O describe cómo crece el trabajo de un algoritmo a medida que crece su entrada, ignorando los factores constantes y los términos de orden inferior. Una función O(n²) no es necesariamente lenta: con diez elementos puede muy bien superar a una O(n log n), pero conforme n aumenta es la tasa de crecimiento la que decide el resultado, y ninguna microoptimización cambia la clase. La complejidad temporal cuenta operaciones básicas; la espacial cuenta memoria. Aquí se informa de ambas, porque una solución que intercambia una por otra solo se juzga con justicia cuando puedes ver las dos.
La definición
Escribe una solución, contrasta la complejidad que crees que tiene con la que su estructura implica realmente, y observa exactamente qué línea la vuelve cuadrática cuando ambas discrepan.
Una función que recorre una lista dentro de un bucle pasa las pruebas y falla en producción. Pegar la función crítica del cambio da un motivo revisable y referenciado por línea para pedir un conjunto en su lugar.
La derivación hace concretas las reglas abstractas: los bloques secuenciales toman el máximo, los anidados se multiplican, y un paso que divide a la mitad aporta un logaritmo.
Analiza las dos y compara las notaciones y el número de operaciones para el tamaño de entrada que realmente esperas, y no en el infinito asintótico.
La mayoría de las herramientas Big-O en línea envían tu fragmento a un modelo de lenguaje y devuelven un O(...) escueto, sin razonamiento. Cuando se equivoca — y con código poco habitual se equivocará — nada en la página te lo advierte. Aquí cada hallazgo indica la línea de la que procede y por cuánto multiplicó la respuesta.
Un troceado dentro de un bucle, una concatenación de cadenas repetida, una comprobación de pertenencia contra una lista en vez de un conjunto: cada uno parece una sola instrucción y cada uno es un recorrido completo. Son la causa más frecuente de una función silenciosamente cuadrática, y aquí se enumeran de forma explícita.
Los bucles anidados sobre dos colecciones distintas son O(n × m), no O(n²). Cuando el código tiene dos dimensiones, el análisis las nombra por separado y te dice a qué variable corresponde cada símbolo.
Los bucles que dependen de los datos, la recursión basada en un pivote y las llamadas de biblioteca desconocidas se declaran como límites, en lugar de taparse con una suposición segura de sí misma.
Cuenta cuántas veces se ejecuta cada instrucción en función del tamaño de la entrada. Los bloques secuenciales toman el máximo de sus costes; los bloques anidados se multiplican. Un bucle que suma una cantidad fija a su contador es lineal; uno que lo multiplica o lo divide es logarítmico. Una función recursiva se resuelve por su recurrencia: dos llamadas sobre la mitad de la entrada más trabajo lineal dan n log n, y dos llamadas sobre n − 1 dan 2^n. Esta calculadora aplica exactamente esas reglas y muestra cada aplicación junto a un número de línea.
Python, JavaScript y TypeScript, Java, C y C++, C# y Go. La detección es automática y puedes cambiarla. El análisis es estructural en lugar de un análisis sintáctico completo, así que también funciona con un fragmento incompleto: el cuerpo de un bucle pegado sin la función que lo contiene se lee correctamente.
Para las formas de bucle, recursión y biblioteca que reconoce, sí, y además muestra su desarrollo para que puedas confirmarlo. Lo que no puede ver es el comportamiento que depende de los datos: un bucle que casi siempre termina antes de tiempo, una tabla hash que degenera en una lista con claves adversas, o una llamada de biblioteca cuyo coste depende de un argumento. Todo eso se declara como límite, sin incorporarlo en silencio a la respuesta.
La complejidad temporal cuenta operaciones a medida que crece la entrada; la espacial cuenta memoria. Con frecuencia se intercambian entre sí: memoizar una función recursiva convierte un tiempo exponencial en lineal a costa de un espacio lineal. Leer solo una de las dos oculta el precio de la otra, y por eso aquí se muestran ambas.
El espacio auxiliar es la memoria que un algoritmo reserva además de la entrada que recibió. Una ordenación in situ es O(1) auxiliar aunque el arreglo que ordena tenga n elementos, porque no reservó ese arreglo. Es la convención que se usa en las entrevistas y en la mayoría de los libros de texto.
Porque los dos bucles recorren colecciones distintas. Sus tamaños son independientes, así que el coste es el producto de dos dimensiones separadas, y reducirlo a n² afirmaría una relación que el código no contiene. Las etiquetas bajo el resultado indican a qué variable corresponde cada símbolo.
No. El análisis se ejecuta en tu navegador. No se envía nada a un servidor, que es también la razón de que no haya espera por una respuesta ni límite de uso.