Este análisis evalúa el desempeño práctico de cuatro algoritmos clásicos de ordenación implementados nativamente en PHP: ordenación por burbuja, ordenación rápida, ordenación por selección y ordenación por inserción. Cada implementación ha sido rediseñada para mejorar claridad, evitar efectos secundarios y garantizar coherencia lógica, manteniendo la esencia algorítmica sin depender de funciones externas ni modificaciones in situ innecesarias.

Ordenación por Burbuja

Implementación iterativa que recorre repetidamente el arreglo, comparando pares adyacentes y reubicándolos si están desordenados. Cada pasada asegura que el elemento más grande no orednado "suba" a su posición final.

function sortBubble(array $values): array {
    $length = count($values);
    for ($pass = 0; $pass < $length - 1; $pass++) {
        $swapped = false;
        for ($idx = 0; $idx < $length - 1 - $pass; $idx++) {
            if ($values[$idx] > $values[$idx + 1]) {
                [$values[$idx], $values[$idx + 1]] = [$values[$idx + 1], $values[$idx]];
                $swapped = true;
            }
        }
        if (!$swapped) break;
    }
    return $values;
}

Ordenación Rápida (Quicksort)

Versión recursiva con partición basada en un pivote. Se selecciona un elemento central como referencia, se separan los valores menores y mayores, y se aplica recursivamente a ambas sublistas. Incluye optimización para arreglos pequeños mediante umbral de tamaño.

function sortQuick(array $items): array {
    $size = count($items);
    if ($size <= 1) return $items;
    
    $pivot = $items[(int)($size / 2)];
    $left = $right = $equal = [];
    
    foreach ($items as $value) {
        if ($value < $pivot) {
            $left[] = $value;
        } elseif ($value > $pivot) {
            $right[] = $value;
        } else {
            $equal[] = $value;
        }
    }
    
    return array_merge(sortQuick($left), $equal, sortQuick($right));
}

Ordenación por Selección

Algoritmo que identifica en cada iteración el valor mínimo restante dentro del segmento no ordenado y lo intercambia con el primer elemento de dicho segmento.

function sortSelection(array $data): array {
    $n = count($data);
    for ($i = 0; $i < $n - 1; $i++) {
        $minIndex = $i;
        for ($j = $i + 1; $j < $n; $j++) {
            if ($data[$j] < $data[$minIndex]) {
                $minIndex = $j;
            }
        }
        if ($minIndex !== $i) {
            [$data[$i], $data[$minIndex]] = [$data[$minIndex], $data[$i]];
        }
    }
    return $data;
}

Ordenación por Inserción

Método que construye la secuencia ordenada uno a uno: cada nuevo elemento se compara con los ya ordenados desde el final hacia adelante, desplazando elementos mayores hasta encontrar su posición correcta.

function sortInsertion(array $sequence): array {
    $len = count($sequence);
    for ($k = 1; $k < $len; $k++) {
        $current = $sequence[$k];
        $pos = $k - 1;
        while ($pos >= 0 && $sequence[$pos] > $current) {
            $sequence[$pos + 1] = $sequence[$pos];
            $pos--;
        }
        $sequence[$pos + 1] = $current;
    }
    return $sequence;
}

Medición de Tiempo de Ejecución

Para comparar objetivamente el rendimeinto, se genera un conjunto de prueba aleatorio de 1600 enteros únicos, se mezcla y se mide el tiempo transcurrido (en segundos) para cada algoritmo usando microtime(true).

function benchmark(callable $algorithm, array $input): float {
    $start = microtime(true);
    $algorithm($input);
    return microtime(true) - $start;
}

$sample = range(1, 2000);
$sample = array_intersect_key($sample, array_flip(array_rand($sample, 1600)));
shuffle($sample);

printf("Ordenación por burbuja: %.6f s\n", benchmark('sortBubble', $sample));
printf("Ordenación rápida:      %.6f s\n", benchmark('sortQuick', $sample));
printf("Ordenación por selección: %.6f s\n", benchmark('sortSelection', $sample));
printf("Ordenación por inserción: %.6f s\n", benchmark('sortInsertion', $sample));