Los algoritmos de ordenamiento son el filtro número uno en las grandes empresas tecnológicas. Si alguna vez te has quedado en blanco en una entrevista técnica cuando te pidieron ordenar un array sin usar .sort(), no eres el único.
Si bien en el día a día solemos confiar en las funciones nativas de JavaScript, entender cómo funcionan las cosas por dentro es lo que separa a un coder promedio de un verdadero desarrollador.
En este post te quiero enseñar cinco algoritmos de ordenamiento con código JavaScript, análisis de complejidad temporal y ejemplos prácticos para que entiendas cuándo usar cada uno y cómo analizar su complejidad (Big O) como un Senior.
¿Por qué debes conocer estos algoritmos?
Si alguna vez te has preguntado por qué los algoritmos de ordenamiento aparecen una y otra vez en entrevistas técnicas, aquí está la respuesta: no se trata solo de ordenar datos.
Dominar estos algoritmos te enseña a:
- Pensar en términos de eficiencia: Aprenderás a analizar cuándo un algoritmo O(n²) es suficiente y cuándo necesitas O(n log n) para que tu aplicación no colapse con grandes volúmenes de datos.
- Entender patrones fundamentales: Técnicas como «divide y vencerás» (Merge Sort, Quicksort) o iteración con comparaciones (Bubble Sort, Selection Sort) son la base para resolver problemas más complejos en tu día a día como desarrollador.
- Destacar en entrevistas técnicas: Según datos de plataformas como LeetCode y HackerRank, el 87% de las entrevistas técnicas incluyen preguntas sobre algoritmos de ordenamiento. No es casualidad: evalúan tu capacidad de análisis, optimización y resolución de problemas.
- Tomar mejores decisiones arquitectónicas: Saber cuándo usar cada algoritmo te permite optimizar desde consultas en bases de datos hasta el rendimiento de interfaces de usuario que manejan listas dinámicas.
Los 5 Algoritmos de Ordenamiento Fundamentales
1. Bubble Sort: El más simple para comenzar
El Bubble Sort es el algoritmo más famoso, no por su eficiencia, sino por su simplicidad. Funciona comparando pares de elementos adyacentes e intercambiándolos si están en el orden incorrecto, repitiendo el proceso hasta que no se necesiten más cambios.
- Cómo funciona: Imagina burbujas de aire subiendo a la superficie. Los elementos más «pesados» (grandes) van cayendo al final de la lista en cada iteración.
- Excelente para aprender lógica de bucles anidados. Terrible para producción con grandes volúmenes de datos.
En el siguiente código podrás ver cómo funciona el bubblesort utilizando javascript:
// Esta función implementa el algoritmo de Bubblesort para ordenar un array.
function bubbleSort(arr) {
// Obtiene el número total de elementos en el array.
let n = arr.length;
// Recorre todos los elementos del array.
for (let i = 0; i < n - 1; i++) {
// Recorre el array desde el principio hasta el final de la parte no ordenada.
for (let j = 0; j < n - i - 1; j++) {
// Compara dos elementos adyacentes, arr[j] y arr[j + 1].
if (arr[j] > arr[j + 1]) {
// Si arr[j] es mayor que arr[j + 1], intercambia los elementos.
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
// Devuelve el array ordenado.
return arr;
}
Pero, ¿cómo se aplica este algoritmo en la vida real? Aquí tienes dos ejemplos:
- Organizar los Contactos en tu Teléfono: Imagina que acabas de guardar un nuevo número en tu teléfono. La solución a tus problemas es el algoritmo de Bubblesort para ordenar tu lista de contactos en orden alfabético, asegurando que puedas encontrar fácilmente el contacto que acabas de guardar.
- Ordenar los Archivos en tu Teléfono: Cuando descargas un nuevo archivo en tu teléfono, el algoritmo de Bubblesort puede ser utilizado para ordenar tus archivos según el momento en que fueron añadidos. De esta manera, siempre tendrás acceso rápido a tus archivos más recientes.
El rendimiento de este algoritmo, aplicando análisis asintotico y utilizando Big O en la complejidad temporal, es Mejor caso: O(n) y Peor caso: O(n^2).
Recuerda que puedes medir el rendimiento de un algoritmo aplicando el análisis asintótico para calcular la complejidad temporal.
Los algoritmos de aqui en adelante se estarán midiendo con la notación Big O y se medirá según su complejidad temporal
2. Insertion Sort: Eficiente para listas pequeñas
Este algoritmo actúa de manera muy similar a como ordenamos una baraja de cartas en la mano. Tomamos una carta, y la movemos hacia atrás hasta encontrar su posición correcta entre las que ya están ordenadas. En otras palabras, construye la lista ordenada elemento por elemento.
- La Ventaja: Aunque técnicamente es lento ($O(n^2)$), el Insertion Sort es extremadamente rápido en listas pequeñas o en listas que ya están casi ordenadas.
- Es útil para arrays pequeños o cuando los datos llegan en tiempo real y ya tienen cierto orden.
// Esta función implementa el algoritmo de Insertion Sort para ordenar un array.
function insertionSort(arr) {
// Este bucle recorre todos los elementos del array, comenzando desde el segundo elemento.
for (let i = 1; i < arr.length; i++) {
// La variable 'key' guarda el valor del elemento actual.
let key = arr[i];
// La variable 'j' se utiliza para recorrer los elementos a la izquierda de 'key'.
let j = i - 1;
// Este bucle mueve los elementos de arr[0..i-1] que son mayores que 'key' a una posición adelante de su posición actual.
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
// Una vez que se ha encontrado la posición correcta para 'key', se inserta en el array.
arr[j + 1] = key;
}
// Devuelve el array ordenado.
return arr;
}
Si buscas ejemplos de la vida real, tenemos:
- Procesamiento de Transacciones en Línea: En escenarios donde se añaden continuamente nuevas transacciones a un conjunto de datos ya ordenado, el Ordenamiento por Inserción resulta eficiente. Por ejemplo, las transacciones con tarjeta de crédito a menudo se añaden a una base de datos ordenada en función de sus marcas de tiempo.
- Ordenación de Camisas en un Armario: Un sastre organiza las camisas en un armario siempre en orden de tamaño, insertando rápidamente las nuevas camisas en la posición correcta moviendo hacia adelante las otras camisas para mantener el lugar correcto para una nueva camisa.
El rendimiento de este algoritmo, aplicando análisis asintotico, es: Mejor caso: O(n) y Peor caso: O(n^2)
3. Selection Sort: Menos intercambios, más eficiencia
A diferencia de los anteriores, el Selection Sort busca el elemento más pequeño de toda la lista y lo coloca al principio. Luego busca el segundo más pequeño y lo pone segundo, y así sucesivamente.
- Diferencia clave: Hace menos intercambios de memoria que el Bubble Sort, pero sigue requiriendo recorrer la lista muchas veces.
- Simple de implementar, pero generalmente superado por Insertion Sort en la práctica.
// Esta función implementa el algoritmo de Selection Sort para ordenar un array.
function selectionSort(arr) {
// Este bucle recorre todos los elementos del array.
for (let i = 0; i < arr.length; i++) {
// Asume que el elemento mínimo es el primer elemento.
let min = i;
// Este bucle recorre los elementos restantes del array.
for (let j = i + 1; j < arr.length; j++) {
// Si encuentra un elemento más pequeño, actualiza 'min'.
if (arr[j] < arr[min]) {
min = j;
}
}
// Si el elemento mínimo no es el primer elemento, intercambia los elementos.
if (min !== i) {
let temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
// Devuelve el array ordenado.
return arr;
}
Si llevamos el algoritmo a la vida real, tenemos dos casos de uso:
- Ordenación de Transacciones Bancarias: Las transacciones bancarias a menudo se añaden a una base de datos ordenada en función de sus marcas de tiempo. El Ordenamiento por Selección puede mantener el ordenado al insertar cada nueva transacción en su posición correcta, asegurando una búsqueda y reporte eficientes.
- Organización de Cartas en un Juego: Imagina que estás jugando un juego de cartas. Este algoritmo puede ser utilizado para ordenar tus cartas de manera eficiente, permitiéndote encontrar rápidamente la carta que necesitas.
El rendimiento de este algoritmo es: Mejor caso: O(n^2) y Peor caso: O(n^2).
4. Merge Sort: Divide y vencerás a O(n log n)
El Merge Sort utiliza el paradigma de «Divide y Vencerás». En lugar de tratar de ordenar toda la lista de golpe, la divide recursivamente en mitades hasta tener listas de 1 solo elemento (que, por definición, ya están ordenadas). Luego, «mezcla» (merge) estas sublistas en orden.
- ¿Por qué es especial?: Tiene una complejidad garantizada de O(n log(n)), lo que lo hace muy consistente y estable, sin importar qué tan desordenados estén los datos iniciales.
- Ideal para bases de datos grandes o cuando necesitas un rendimiento predecible.
// Esta función implementa el algoritmo de Merge Sort para ordenar un array.
function mergeSort(arr) {
// Si el array tiene 0 o 1 elementos, ya está ordenado.
if (arr.length <= 1) {
return arr;
}
// Encuentra el índice medio del array.
const middle = Math.floor(arr.length / 2);
// Divide el array en dos mitades.
const left = arr.slice(0, middle);
const right = arr.slice(middle);
// Ordena cada mitad y las combina.
return merge(mergeSort(left), mergeSort(right));
}
// Esta función combina dos arrays ordenados en un solo array ordenado.
function merge(left, right) {
let resultArray = [], leftIndex = 0, rightIndex = 0;
// Mientras haya elementos en ambas mitades...
while (leftIndex < left.length && rightIndex < right.length) {
// Si el elemento de la izquierda es menor, lo añade al array resultante.
if (left[leftIndex] < right[rightIndex]) {
resultArray.push(left[leftIndex]);
leftIndex++;
} else {
// Si el elemento de la derecha es menor, lo añade al array resultante.
resultArray.push(right[rightIndex]);
rightIndex++;
}
}
// Añade los elementos restantes de ambas mitades al array resultante.
return resultArray
.concat(left.slice(leftIndex))
.concat(right.slice(rightIndex));
}
Con dos ejemplos de la vida real tenemos:
- Ordenación de Información de Usuarios en Redes Sociales: Las redes sociales manejan grandes conjuntos de datos de usuarios. El algoritmo de Merge Sort puede ser utilizado para ordenar estos datos de manera eficiente.
- Organización de Productos en Plataformas de Comercio Electrónico: En una plataforma de comercio electrónico, los productos pueden ser ordenados en base a sus precios o calificaciones. El algoritmo de Merge Sort es una excelente opción para realizar esta tarea debido a su eficiencia con listas grandes.
El rendimiento de este algoritmo es: Mejor caso: O(nlog) y Peor caso: O(nlog)
5. Quicksort: El favorito de las grandes bases de datos
El Quicksort se lleva la corona algoritmos de ordenamiento en memoria. También usa «Divide y Vencerás», pero su secreto está en el Pivote.
- Elige un elemento como «pivote».
- Mueve todos los elementos menores a la izquierda del pivote y los mayores a la derecha.
- Repite el proceso recursivamente.
El Riesgo: Si eliges mal el pivote (por ejemplo, siempre el primero en una lista ya ordenada), su rendimiento cae drásticamente. Pero en promedio, es el más veloz.
El favorito de las librerías estándar de lenguajes de programación y sistemas operativos.
// Esta función implementa el algoritmo de Quicksort para ordenar un array.
function quickSort(arr) {
// Si el array tiene 0 o 1 elementos, ya está ordenado.
if (arr.length <= 1) {
return arr;
}
// Elige el último elemento como pivote.
const pivot = arr[arr.length - 1];
// Crea dos arrays para los elementos menores y mayores que el pivote.
const leftArr = [];
const rightArr = [];
// Recorre los elementos del array (excepto el pivote).
for (const el of arr.slice(0, arr.length - 1)) {
// Si el elemento es menor que el pivote, lo añade al array de la izquierda.
// Si el elemento es mayor que el pivote, lo añade al array de la derecha.
el < pivot ? leftArr.push(el) : rightArr.push(el);
}
// Ordena las dos mitades y las combina con el pivote en el medio.
return [...quickSort(leftArr), pivot, ...quickSort(rightArr)];
}
Y unos ejemplos de aplicación en la vida real:
- Sistemas de Gestión de Bases de Datos: Quicksort se utiliza para ordenar grandes conjuntos de datos en bases de datos para optimizar el rendimiento de las consultas.
- Sitios de Comercio Electrónico: Quicksort puede ser utilizado para ordenar productos por precio, calificación u otros atributos para mejorar la experiencia del usuario.
El rendimiento de este algoritmo es: Mejor caso: O(nlog(n)) y Peor caso: O(n^2)
Tabla Comparativa: ¿Cuándo usar cada algoritmo?
Esta tabla te ayudará a decidir rápidamente qué algoritmo usar según tu situación:
| Algoritmo | Mejor Caso | Peor Caso | ¿Cuándo usarlo? | Nivel de Dificultad |
|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | Listas muy pequeñas o casi ordenadas. Ideal para aprender conceptos básicos. | ⭐ Fácil |
| Insertion Sort | O(n) | O(n²) | Listas pequeñas o cuando los datos llegan de forma continua (streaming). Eficiente con datos casi ordenados. | ⭐⭐ Fácil-Medio |
| Selection Sort | O(n²) | O(n²) | Cuando necesitas minimizar intercambios de memoria. Útil en sistemas con escritura costosa. | ⭐⭐ Fácil-Medio |
| Merge Sort | O(n log n) | O(n log n) | Listas grandes donde necesitas rendimiento consistente. Perfecto para datos en disco o sistemas distribuidos. | ⭐⭐⭐ Medio |
| Quicksort | O(n log n) | O(n²) | Listas grandes en memoria RAM. El más rápido en promedio. Usado en librerías estándar de muchos lenguajes. | ⭐⭐⭐ Medio-Avanzado |
💡 Tip profesional: En la práctica, Quicksort y Merge Sort son los más utilizados en producción. Los otros tres son excelentes para entender fundamentos y resolver casos específicos con restricciones de memoria o datos pequeños.
Conclusión
Dominar estos 5 algoritmos te da una base sólida, pero la teoría sin práctica se olvida (recuerda la Curva del Olvido).
Tu reto para hoy: Abre tu editor de código, borra las soluciones y trata de implementar un Quicksort desde cero sin mirar. Es difícil al principio, pero así es como se aprende de verdad.
Te invito a elevar tus conocimiento leyendo la guía de Estructuras de Datos en JS: Arrays, Listas y Árboles para entender dónde aplicar estos algoritmos y resolver problemas desde otro punto de vista.
Espero que este post te sea de útilidad y te ayude a mejorar tus habilidades de programación. No olvides compartir si te ha ayudado.
👉 Únete a mi Canal de WhatsApp para más recursos
👉 Sigueme en mis redes sociales para más contenido de programación y productividad