Intercambio de elementos en un arreglo

function intercambiar(a, b, arreglo) {
    let temp = arreglo[a];
    arreglo[a] = arreglo[b];
    arreglo[b] = temp;
}

Ordenamiento de burbuja (Bubble Sort)

Compara pares de elementos adyacentes y los intercambia si el primero es mayor que el segundo. Los elementos más grandes "suben" hacia el final del arreglo progresivamente.

Versión optimizada: al restar el número de iteraciones externas del bucle interno se evitan comparaciones innecesarias. Cada pasada coloca el valor máximo en la posición arreglo.longitud - i.

const ordenamientoBurbuja = (arreglo = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const longitud = arreglo.length;
    for (let i = 0; i < longitud; i++) {
        for (let j = 0; j < longitud - i; j++) {
            const actual = arreglo[j];
            const siguiente = arreglo[j + 1];
            if (actual > siguiente) {
                [arreglo[j], arreglo[j + 1]] = [arreglo[j + 1], arreglo[j]];
            }
        }
    }
    return arreglo;
};

Ordenamiento por selección (Selection Sort)

Encuentra el valor mínimo de la estructura y lo coloca en la primera posición, luego busca el segundo mínimo y lo coloca en la segunda posición, y así sucesivamente.

Es el comportamiento inverso al burbuja: cada vuelta coloca el mínimo en la posición i.

const ordenamientoSeleccion = (arreglo = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const longitud = arreglo.length;
    for (let i = 0; i < longitud - 1; i++) {
        let indiceMinimo = i;
        for (let j = i + 1; j < longitud; j++) {
            if (arreglo[j] < arreglo[indiceMinimo]) {
                indiceMinimo = j;
            }
        }
        if (arreglo[i] > arreglo[indiceMinimo]) {
            [arreglo[i], arreglo[indiceMinimo]] = [arreglo[indiceMinimo], arreglo[i]];
        }
    }
    return arreglo;
};

Ordenamiento por inserción (Insertion Sort)

Construye el arreglo ordenado insertando un elemento a la vez en la posición correcta.

function ordenamientoInsercion(arreglo) {
    for (let i = 1; i < arreglo.length; i++) {
        let indiceAnterior = i - 1;
        let actual = arreglo[i];
        while (indiceAnterior >= 0 && actual < arreglo[indiceAnterior]) {
            arreglo[indiceAnterior + 1] = arreglo[indiceAnterior];
            indiceAnterior--;
        }
        arreglo[indiceAnterior + 1] = actual;
    }
    return arreglo;
}

Ordenamiento por mezcla (Merge Sort)

const ordenamientoMezcla = (arreglo = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const longitud = arreglo.length;
    if (longitud === 1) return arreglo;
    const mitad = Math.floor(longitud / 2);
    const izquierda = arreglo.slice(0, mitad);
    const derecha = arreglo.slice(mitad);
    const combinar = (izq, der) => {
        let i = 0, j = 0;
        const resultado = [];
        while (i < izq.length && j < der.length) {
            if (izq[i] < der[j]) {
                resultado.push(izq[i++]);
            } else {
                resultado.push(der[j++]);
            }
        }
        while (i < izq.length) resultado.push(izq[i++]);
        while (j < der.length) resultado.push(der[j++]);
        return resultado;
    };
    return combinar(ordenamientoMezcla(izquierda), ordenamientoMezcla(derecha));
};

Ordenamiento rápido (Quick Sort)

Algoritmo recursivo basado en la técnica de divide y vencerás. Se recomienda usar slice en lugar de splice para evitar afectar el rendimiento.

const ordenamientoRapido = (arreglo = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const longitud = arreglo.length;
    if (longitud <= 1) return arreglo;
    const menores = [];
    const mayores = [];
    const pivote = arreglo[0];
    for (let i = 1; i < longitud; i++) {
        const valor = arreglo[i];
        if (valor < pivote) {
            menores.push(valor);
        } else {
            mayores.push(valor);
        }
    }
    return ordenamientoRapido(menores).concat(pivote, ordenamientoRapido(mayores));
};

Ordenamiento por conteo (Counting Sort) – versión optimizada

Usa el valor mínimo para evitar desperdicio de espacio en el arreglo de frecuencias.

const ordenamientoConteo = (arreglo = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const longitud = arreglo.length;
    const minimo = Math.min(...arreglo);
    const maximo = Math.max(...arreglo);
    const contadores = new Array(maximo - minimo + 1).fill(0);
    for (let i = 0; i < longitud; i++) {
        const valor = arreglo[i];
        contadores[valor - minimo]++;
    }
    const resultado = [];
    for (let i = 0; i < contadores.length; i++) {
        let cantidad = contadores[i];
        while (cantidad > 0) {
            resultado.push(i + minimo);
            cantidad--;
        }
    }
    return resultado;
};

Ordenamiento por base (Radix Sort)

Algoritmo interesante que ordena según los dígitos (en cada base) de los números. Pendiente de implementación.

function ordenamientoRadix(arreglo) {
    // Pendiente
}