400 ms
Cargando aplicación...
Preparando tu experiencia meskeIA
Bubble, Quick, Merge, Heap... paso a paso con tu propio array
Complejidad, estabilidad y casos de uso
La ordenación es uno de los problemas más estudiados en informática. No existe un algoritmo universalmente mejor: la mejor opción depende del tamaño del array, si está parcialmente ordenado, si hay duplicados, si la memoria es limitada y si necesitas estabilidad. Este simulador te ayuda a entender por qué un mismo array puede requerir 45 comparaciones con Bubble Sort y solo 18 con Merge Sort.
| Algoritmo | Mejor | Promedio | Peor | Espacio | Estable | Cuándo usar |
|---|---|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) | Sí | Solo enseñanza, datos pequeños |
| Selection Sort | O(n²) | O(n²) | O(n²) | O(1) | No | Cuando minimizar movimientos importa |
| Insertion Sort | O(n) | O(n²) | O(n²) | O(1) | Sí | Arrays pequeños o casi ordenados |
| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) | Sí | Necesitas estabilidad y peor caso garantizado |
| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) | No | Datos generales en memoria, rápido en promedio |
| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) | No | Memoria limitada y peor caso garantizado |
| Counting Sort | O(n + k) | O(n + k) | O(n + k) | O(k) | Sí | Enteros con rango k pequeño |
Una biblioteca con 50.000 libros recibe un pedido de reordenación alfabética. Si los datos ya estaban casi ordenados (los libros nuevos van al final), Insertion Sort termina en O(n). Si están totalmente revueltos, Merge Sort es la opción profesional: O(n log n) garantizado y estable (útil para mantener el orden secundario por autor).
Mostrar el top 10 de jugadores de los últimos 5 minutos entre 100.000 partidas activas. Si solo te interesa el top-K, Heap Sort permite extraer los K mayores en O(n + k log n), evitando ordenar todo el conjunto.
Ordenar 10 millones de edades de pacientes (rango 0-120). Como el rango k es pequeño respecto a n, Counting Sort es ideal: O(n + k) lineal. Quick Sort necesitaría ~230 millones de operaciones; Counting Sort apenas 10 millones más 120.
En un microcontrolador con 8 KB de RAM, no puedes permitirte el array auxiliar de Merge Sort. Heap Sort ordena en sitio (O(1) extra) y garantiza O(n log n) incluso en el peor caso —algo que Quick Sort no asegura sin pivote aleatorio.
Para n = 1.000: O(n²) son 1 millón de operaciones, O(n log n) son ~10.000. Para n = 1.000.000: O(n²) es 1 billón (~30 minutos), O(n log n) son ~20 millones (~1 segundo). La diferencia crece exponencialmente con el tamaño.
Por eso Bubble es útil para enseñar pero nadie lo usa en producción con miles de elementos.
Un algoritmo es estable si elementos con la misma clave conservan su orden relativo original. Si tienes una lista ordenada por nombre y la reordenas por edad con un algoritmo estable, los de la misma edad seguirán por orden alfabético.
Estables: Bubble, Insertion, Merge, Counting. No estables: Selection, Quick, Heap.
Cuando el pivote elegido es siempre el peor (mín o máx), Quick degenera a O(n²) y con n pequeño puede ser más lento que Insertion. Por eso las implementaciones reales usan pivote aleatorio o mediana de tres.
Prueba el preset "Inverso" con Quick Sort para ver el peor caso clásico.
Para fusionar dos mitades ordenadas necesita un array auxiliar del mismo tamaño que el original. Esto suma O(n) de espacio. Heap Sort y Quick Sort lo hacen en sitio (O(1) y O(log n) respectivamente).
En entornos con memoria limitada (sistemas embebidos), Heap Sort suele ser preferible.
Sí, pero con una trampa: depende del rango k de valores. Si k = 100 y n = 1.000.000, es brutalmente rápido. Si k = 10.000.000.000 y n = 100, es absurdamente lento. La complejidad real es O(n + k), no solo O(n).
Útil para edades, notas, días del mes... no para precios o IDs grandes.
Python y Java usan Timsort, un híbrido de Merge e Insertion optimizado para datos del mundo real (que suelen tener subsecuencias ordenadas). V8 de Chrome también cambió a Timsort en 2018. C++ usa Introsort (Quick + Heap + Insertion según el caso).
En la práctica nunca implementarás un sort básico: usarás arr.sort() y confiarás en el optimizado por la librería estándar.
Si n < 50, casi cualquier algoritmo es aceptable. Si n > 10.000, descarta los O(n²) automáticamente.
Si los datos llegan ya parcialmente ordenados (logs por fecha, datos incrementales), Insertion Sort es O(n) y supera a Merge en estos casos.
Si vas a ordenar por múltiples claves en sucesión (primero por nombre, luego por edad), necesitas un algoritmo estable: Merge, Insertion o Counting.
Si no puedes permitirte O(n) de espacio extra (sistemas embebidos), descarta Merge. Heap ordena en sitio garantizando O(n log n).
Si los valores son enteros y el rango k es comparable a n (edades, notas, días), Counting Sort es lineal y supera a cualquier comparativo.
En código real usa Array.sort(), Collections.sort() ostd::sort(). Están optimizadas y son híbridas.
Para arrays pequeños (n < 50), las diferencias son irrelevantes. No optimices algo que no es cuello de botella.
Si implementas Quick Sort, usa un pivote aleatorio o mediana de tres. Evita el peor caso cuadrático en arrays casi ordenados.
Si ordenas tablas multi-criterio, la estabilidad es clave. Merge Sort > Quick Sort para ordenar por varias columnas en sucesión.
Si el array no cabe en memoria (terabytes), ningún algoritmo en sitio funciona. Necesitas external merge sort con archivos temporales en disco.
Probar tu algoritmo con array inverso, casi ordenado y con duplicados revela comportamientos que un array aleatorio oculta.
Array.sort() en JavaScript es estable desde 2019 (V8), pero Arrays.sort() de int[] en Java NO lo es.