meskeIA

Visualizador de Algoritmos de Ordenación

Siete algoritmos animados paso a paso, con el pseudocódigo resaltado línea a línea y el recuento de comparaciones y movimientos en vivo

© 2026 meskeIA© 2026
Array de 25 valores
Normal
Comparando
Intercambiando
Ordenado
0
Comparaciones
0
Movimientos
intercambios y escrituras
0
Accesos
0ms
Tiempo

Pseudocódigo

1procedimiento bubbleSort(A)
2 para i desde 0 hasta n-2
3 intercambiado = falso
4 para j desde 0 hasta n-i-2
5 si A[j] > A[j+1] entonces
6 intercambiar(A[j], A[j+1])
7 intercambiado = verdadero
8 fin si
9 fin para
10 si no intercambiado entonces salir
11 fin para
12fin procedimiento

Complejidad

Mejor
O(n)
Promedio
O(n²)
Peor
O(n²)
Espacio
O(1)

Compara elementos adyacentes e intercambia si están desordenados. Si una pasada entera no intercambia nada, para: por eso con un array ya ordenado basta una pasada (O(n)). Simple pero ineficiente para arrays grandes.

Tamaño del array:
Casos clásicos:

Prueba Inverso con Quick Sort para ver su peor caso, o Casi ordenado con Insertion Sort para ver por qué a veces gana a los O(n log n).

Números enteros del 1 al 100 separados por comas. Útil para probar casos concretos: un array ya ordenado, uno al revés o con valores repetidos.

Aprende Algoritmos de Ordenación: Guía Completa con Ejemplos

Comprende las diferencias, cuándo usar cada algoritmo y cómo elegir el más adecuado para tu proyecto

Comparativa Completa de Algoritmos

AlgoritmoMejor CasoCaso PromedioPeor CasoEspacioEstableIdeal para
Bubble SortO(n)O(n²)O(n²)O(1)SíAprender, arrays muy pequeños
Selection SortO(n²)O(n²)O(n²)O(1)NoMinimizar escrituras en memoria
Insertion SortO(n)O(n²)O(n²)O(1)SíArrays casi ordenados, pequeños
Quick SortO(n log n)O(n log n)O(n²)O(log n)NoUso general, datos aleatorios
Merge SortO(n log n)O(n log n)O(n log n)O(n)SíOrdenación garantizada, objetos
Heap SortO(n log n)O(n log n)O(n log n)O(1)NoGarantía O(n log n) sin memoria extra
Counting SortO(n + k)O(n + k)O(n + k)O(k) la animada · O(n + k) la estableSí, la versión con suma acumuladaEnteros con rango k acotado

¿Quién usa este visualizador?

🎓
Estudiante de Informática
1º y 2º de grado, FP DAM/DAW
Visualiza cómo funciona cada algoritmo paso a paso para entender los conceptos de complejidad. Ideal para preparar exámenes de Algoritmos y Estructuras de Datos.
💼
Dev Junior en Entrevistas
Preparando entrevistas técnicas
Repasa los algoritmos clásicos que preguntan en entrevistas de empresas tech. Comprende el trade-off entre Quick Sort y Merge Sort para explicarlo con fluidez.
🏫
Profesor / Formador
Docentes de programación
Usa la visualización en clase para explicar de forma gráfica cómo se comportan los algoritmos. El modo paso a paso permite avanzar al ritmo de los alumnos.
🔍
Curioso con Experiencia
Devs con varios años de experiencia
Refresca conceptos que quizás no usas en el día a día. Comprueba visualmente por qué Insertion Sort supera a Quick Sort en arrays muy pequeños o ya ordenados.

Preguntas Frecuentes sobre Algoritmos

¿Por qué Quick Sort es más rápido en la práctica si tiene peor caso O(n²)?
La constante oculta en la notación Big O importa. Quick Sort tiene muy buen rendimiento de caché (accede a memoria secuencialmente) y el peor caso O(n²) es estadísticamente raro con datos aleatorios. Con pivote aleatorio, la probabilidad del peor caso es despreciable.
¿Cuándo usar Merge Sort en lugar de Quick Sort?
Usa Merge Sort cuando necesites rendimiento garantizado O(n log n) siempre (Quick Sort puede degradarse), cuando necesites estabilidad (mantener el orden de elementos iguales), o cuando ordenes listas enlazadas (Merge Sort no necesita acceso aleatorio).
¿Qué significa exactamente que un algoritmo sea "estable"?
Un algoritmo estable mantiene el orden relativo de los elementos con la misma clave. Ejemplo: si ordenas una lista de personas por apellido y dos personas tienen el mismo apellido, un algoritmo estable mantiene el orden original entre ellas. Bubble, Insertion y Merge Sort son estables; Selection y Quick Sort no lo son.
¿Existen algoritmos más rápidos que O(n log n) para ordenar?
Sí, pero solo cuando los datos tienen restricciones. Counting Sort, Radix Sort y Bucket Sort pueden lograr O(n) si los valores son enteros en un rango conocido. Para ordenación por comparación pura, O(n log n) es el límite teórico demostrado matemáticamente.
¿Por qué se enseña Bubble Sort si es tan ineficiente?
Bubble Sort es pedagogicamente valioso: su lógica es intuitiva, fácil de implementar y debuggear, y sirve para introducir conceptos como comparaciones, intercambios y complejidad. En producción nunca se usa directamente, pero entenderlo afianza las bases.
¿Qué es un "pivote" en Quick Sort y por qué importa su elección?
El pivote es el elemento sobre el que se divide el array en dos partes: menores y mayores. Una mala elección (siempre el mínimo o máximo) lleva al peor caso O(n²). La estrategia "mediana de tres" (primer, medio y último elemento) o pivote aleatorio evita este problema.
¿Cuándo es mejor Insertion Sort que Quick Sort?
Para arrays de menos de 10-20 elementos, Insertion Sort suele ganar por su constante pequeña y mejor comportamiento de caché. Además, si el array está casi ordenado (pocas inversiones), Insertion Sort es casi O(n), mientras que un Quick Sort con pivote fijo (el último elemento, como el de esta app) se acerca a O(n²): pruébalo con el caso «Casi ordenado». Con pivote aleatorio o mediana de tres vuelve a O(n log n). Por eso muchos Quick Sort modernos cambian a Insertion Sort para subproblemas pequeños.
¿Qué algoritmo usa JavaScript internamente en Array.sort()?
Desde 2019 (V8 v7.0+), JavaScript usa Tim Sort, un híbrido de Merge Sort e Insertion Sort diseñado para datos reales. Es estable, con complejidad O(n log n) en el peor caso y O(n) cuando los datos ya están parcialmente ordenados (muy común en la práctica).

Cómo elegir el algoritmo correcto: 6 pasos

  1. 1
    Evalúa el tamaño de los datos
    ¿Menos de 50 elementos? Considera Insertion Sort (constante pequeña, buen caché). ¿Cientos o miles? O(n log n) es obligatorio: Quick Sort o Merge Sort. ¿Millones? Considera algoritmos especializados (Radix Sort si son enteros).
  2. 2
    Analiza si los datos están parcialmente ordenados
    Si los datos llegan casi ordenados (ej: logs con timestamps), Insertion Sort es O(n). Si son completamente aleatorios, Quick Sort con pivote aleatorio es óptimo. Si son datos reales mixtos, Tim Sort (el de JavaScript) es la mejor opción general.
  3. 3
    Decide si necesitas estabilidad
    ¿Ordenas por múltiples criterios? (ej: primero por precio, luego por nombre). Si la ordenación secundaria ya está hecha y quieres preservarla, necesitas un algoritmo estable: Merge Sort, Insertion Sort o Tim Sort.
  4. 4
    Considera las restricciones de memoria
    Si la memoria es crítica (sistemas embebidos, arrays gigantes), usa algoritmos in-place: Quick Sort O(log n), Heap Sort O(1). Si tienes memoria disponible, Merge Sort O(n) extra te da estabilidad y rendimiento garantizado.
  5. 5
    Evalúa el peor caso aceptable
    En sistemas críticos (tiempo real, banca), el peor caso importa tanto como el promedio. Quick Sort puede degradarse a O(n²) en datos adversariales. Merge Sort garantiza O(n log n) siempre. Para uso general, Quick Sort aleatorio es seguro estadísticamente.
  6. 6
    Mide y decide con benchmarks reales
    La teoría guía, pero los datos reales deciden. Haz benchmarks con tu conjunto de datos específico. A veces una implementación bien optimizada de un algoritmo “peor” supera a una naïve de un algoritmo “mejor”. Usa herramientas como jsperf.com o console.time() en JavaScript.

Tips y Errores Frecuentes

Tips de Experto
Para arrays pequeños (<20 elementos), Insertion Sort gana por la constante pequeña y mejor localidad de caché, aunque su Big O sea peor.
Quick Sort con pivote aleatorio convierte el peor caso O(n²) en un evento estadísticamente despreciable sin coste algorítmico.
En JavaScript usa Array.sort() (Tim Sort) en lugar de reimplementar: está altamente optimizado y es estable desde ES2019.
Selection Sort tiene una ventaja única: minimiza el número de escrituras en memoria (máximo n-1 intercambios). Útil en EEPROM con escrituras limitadas.
Para ordenar listas enlazadas, Merge Sort es natural porque no necesita acceso aleatorio. Quick Sort en listas enlazadas es complicado.
Si tus datos son enteros en rango acotado, Counting Sort o Radix Sort logran O(n), superando el límite teórico de comparación O(n log n).
Errores Frecuentes
Confundir complejidad media con peor caso. Quick Sort tiene O(n log n) promedio pero O(n²) peor caso, no al revés.
Asumir que O(n log n) siempre es más rápido que O(n²). Para arrays pequeños, la constante oculta en Big O puede invertir el resultado real.
Ignorar la estabilidad. Si ordenas registros multi-campo (nombre + apellido), un algoritmo inestable puede destruir la ordenación secundaria.
Creer que Quick Sort es O(log n) en espacio porque es in-place. La pila de llamadas recursivas ocupa O(log n) en el caso medio y O(n) en el peor.
Usar Bubble Sort en producción “porque los arrays son pequeños”. Insertion Sort es siempre mejor que Bubble Sort para arrays pequeños.
Confundir número de comparaciones con número de intercambios. Selection Sort minimiza intercambios pero maximiza comparaciones.

Conceptos Clave de Complejidad

¿Qué significa O(n²) en la práctica?

La notación O grande describe cómo crece el tiempo de ejecución con el tamaño de la entrada. O(n²) significa que si duplicas el tamaño del array, el tiempo se cuadruplica. O(n log n) crece mucho más lento: un array de 1.000 elementos tarda ~10.000 operaciones en vez de ~1.000.000 con O(n²).

Algoritmos estables vs. inestables

Un algoritmo estable mantiene el orden relativo de elementos con claves iguales. Por ejemplo, si ordenas estudiantes por nota y dos tienen la misma nota, un algoritmo estable los mantiene en el orden original. Estables: Bubble, Insertion, Merge Sort. Inestables: Selection Sort, Quick Sort (implementación estándar).

In-place vs. memoria adicional

Los algoritmos in-place (Bubble, Selection, Insertion, Quick) ordenan usando solo O(1) o O(log n) de memoria extra. Merge Sort necesita O(n) de memoria adicional para el array temporal durante la fusión, lo que puede ser un problema con arrays de cientos de millones de elementos.

Tabla Comparativa Completa

AlgoritmoMejor casoCaso medioPeor casoEspacioEstableCuándo usarlo
Bubble SortO(n)O(n²)O(n²)O(1)SíSolo para enseñar conceptos o detectar arrays ya ordenados
Selection SortO(n²)O(n²)O(n²)O(1)NoCuando minimizar escrituras en memoria es crítico (EEPROM)
Insertion SortO(n)O(n²)O(n²)O(1)SíArrays pequeños (<50) o casi ordenados
Merge SortO(n log n)O(n log n)O(n log n)O(n)SíCuando necesitas garantías de peor caso o estabilidad
Quick SortO(n log n)O(n log n)O(n²)O(log n)NoUso general en memoria, datos aleatorios con pivote aleatorio
Heap SortO(n log n)O(n log n)O(n log n)O(1)NoCuando necesitas O(1) espacio extra con peor caso garantizado
Counting SortO(n+k)O(n+k)O(n+k)O(k) la animada · O(n+k) la estableSí, la versión con suma acumuladaEnteros en rango pequeño y conocido (k << n)

Escenarios Reales de Uso

Entrevista técnica

“FAANG pregunta 'ordena este array en O(n log n)'. Merge Sort garantiza el peor caso. Quick Sort es más rápido en la práctica pero tiene peor caso O(n²).”

Tip: Mergesort para garantías, Quicksort para rendimiento medio.

Motor de juego

“Ordenar 10.000 entidades por distancia al jugador cada frame (60fps). Insertion sort para arrays casi ordenados (movimiento incremental) es 10x más rápido que Quicksort.”

Tip: Analiza si los datos están casi ordenados antes de elegir algoritmo.

Base de datos

“PostgreSQL usa introsort (híbrido QuickSort + HeapSort + InsertionSort) para ORDER BY. Cambia a algoritmo estable cuando necesita preservar orden relativo.”

Tip: Las BDs usan algoritmos híbridos adaptativos, no puros.

Análisis científico

“Ordenar 10⁹ mediciones de sensor en disco (externo): Merge Sort externo en bloques de 64MB, 1,2TB procesados en 4 horas.”

Tip: Para datos que no caben en RAM, solo Merge Sort externo es viable.

Preguntas Frecuentes (versión avanzada)

¿Por qué Quicksort es más rápido que Mergesort si tienen la misma complejidad O(n log n)?

La constante importa: Quicksort tiene mejor localidad de caché (acceso secuencial), menos operaciones de copia y overhead de recursión. En la práctica es 2-3x más rápido que Mergesort para datos en memoria.

¿Cuándo usar Bubble Sort?

Casi nunca en producción. Solo es útil para enseñar conceptos o detectar si un array ya está ordenado (termina en O(n) con la variante optimizada). Con n>100 elementos, cualquier otro algoritmo lo supera.

¿Qué significa que un algoritmo sea estable?

Que elementos con igual clave mantienen su orden relativo original. Crucial cuando ordenas por múltiples criterios: primero por apellido, luego por nombre. Mergesort y Insertion Sort son estables; Quicksort y Heapsort no.

¿Qué es el algoritmo Timsort?

El algoritmo de Python (sort y sorted) y de Java para objetos (Arrays.sort con objetos y Collections.sort; con tipos primitivos Java usa Dual-Pivot Quicksort). Híbrido de Mergesort + InsertionSort que detecta subsecuencias ya ordenadas (runs) y las combina. Rendimiento real O(n) en datos casi ordenados, O(n log n) en peor caso.

¿Por qué el peor caso de Quicksort es O(n²)?

Ocurre cuando el pivote elegido siempre es el mínimo o máximo: array ya ordenado con pivote en posición 0. Solución: elegir pivote aleatoriamente o usar ‘mediana de tres’.

¿Qué es la ordenación externa?

Cuando los datos no caben en RAM. Se divide en bloques que sí caben, se ordena cada bloque, se guardan en disco y se fusionan (Merge Sort externo). Usado en bases de datos, Hadoop MapReduce.

¿Qué es Counting Sort y cuándo es más rápido que O(n log n)?

Cuando el rango de valores es pequeño y conocido. Crea un array de contadores. Ordena n=1.000.000 enteros de 0-255 en O(n+k) ≈ O(n). Imposible para números flotantes o strings arbitrarios.

¿Cuál es el límite teórico de la ordenación por comparación?

Ω(n log n) — demostrado por el argumento del árbol de decisión. Ningún algoritmo basado en comparaciones puede ser más rápido en el caso general. Radix Sort y Counting Sort lo superan porque no comparan.

Cómo elegir el algoritmo correcto: 7 pasos

1
¿Los datos caben en RAM?

No → Merge Sort externo. Sí → continúa.

2
¿Cuántos elementos?

n<50 → Insertion Sort (constante pequeña). n>50 → continúa.

3
¿Los datos están casi ordenados?

Sí → Insertion Sort o Timsort. No → continúa.

4
¿El rango de valores es pequeño y entero?

Sí → Counting Sort o Radix Sort (O(n)). No → continúa.

5
¿Necesitas orden estable?

Sí → Mergesort. No → continúa.

6
¿Tienes restricciones de espacio (O(1) extra)?

Sí → Heapsort. No → Quicksort con pivote aleatorio.

7
En producción: usa la librería del lenguaje

Python sort(), Java Arrays.sort(), C++ std::sort() — son híbridos optimizados (Timsort, Dual-Pivot Quicksort, Introsort) que superan cualquier implementación manual.

Mejores Prácticas

Confía en la librería

Python sort()/sorted() usa Timsort; Java Arrays.sort(), Timsort con objetos y Dual-Pivot Quicksort con primitivos; C++ std::sort(), Introsort. Más rápidos que cualquier implementación propia.

Mide antes de optimizar

Con n pequeño (decenas o cientos) la diferencia entre O(n²) y O(n log n) no se nota; con 10.000 elementos ya son decenas o cientos de milisegundos frente a unos pocos. Optimiza cuando el profiler lo confirme con tus datos.

Analiza tus datos

¿Ya casi ordenados? ¿Rango pequeño? ¿Muchos duplicados? La respuesta cambia el algoritmo óptimo.

Pivote en Quicksort

Nunca uses siempre el primer elemento como pivote. Mediana de tres o pivote aleatorio evita el caso O(n²).

Localidad de caché

En arrays grandes, los algoritmos que recorren la memoria de forma secuencial (Quicksort en su partición, Mergesort en la fusión) aprovechan mejor la caché L1/L2. Heapsort es el contraejemplo clásico: salta de la posición i a la 2i+1 y por eso suele ser más lento que Quicksort aunque tenga la misma complejidad.

Considera la estructura

Si ordenas objetos por un campo, extrae el campo a un array auxiliar, ordena índices y reordena — evita mover objetos grandes.

Errores clásicos al elegir algoritmo de ordenación

  • Usar Bubble Sort en producción: O(n²) con constante grande. Con n=100.000 elementos, es 10.000x más lento que Mergesort.
  • No verificar estabilidad: Si ordenas por múltiples criterios, un algoritmo inestable puede corromper el orden previo.
  • Quicksort con pivote fijo en datos ordenados: El caso más común de degradación a O(n²). Usa pivote aleatorio o mediana de tres.
  • Reimplementar sort() en lugar de usarlo: Las implementaciones del lenguaje tienen optimizaciones que tardan años en desarrollar.
  • Ignorar el espacio auxiliar: Mergesort necesita O(n) espacio extra. En sistemas embebidos con RAM limitada puede ser un bloqueante.
  • Comparar por floating point sin epsilon: sorted() con comparación directa de floats puede ser inconsistente por errores de precisión.

Apps relacionadas