Algoritmos y estructuras de datos en PHP: guía práctica

Los algoritmos y estructuras de datos son los cimientos de la programación. No importa qué lenguaje uses — entender cómo ordenar eficientemente, buscar en millones de registros o gestionar memoria es lo que separa a un programador de un gran programador.

¿Por qué importa la eficiencia?

Un algoritmo que tarda 1 segundo en ordenar 1,000 elementos puede tardar 16 minutos en ordenar 1,000,000 — si su complejidad es O(n²). Otro algoritmo con complejidad O(n log n) haría lo mismo en 20 segundos. A escala real, esta diferencia es entre una aplicación funcional y una inutilizable.

Notación Big O

Estructuras de datos fundamentales

Array / Lista

// PHP — arrays son dinámicos y admiten tipos mixtos
$ips = ['192.168.1.1', '10.0.0.1', '172.16.0.1'];
$ips[] = '8.8.8.8';           // O(1) agregar al final
$primera = $ips[0];            // O(1) acceso por índice
array_splice($ips, 1, 0, ['192.168.1.2']);  // O(n) insertar en medio

Stack (pila) — LIFO

// Útil para: historial de navegación, eval de expresiones, backtracking
$stack = new SplStack();
$stack->push('inicio.php');    // push O(1)
$stack->push('articulos.php');
$stack->push('articulo-1.php');

$actual = $stack->top();       // peek: 'articulo-1.php'
$anterior = $stack->pop();     // pop O(1): regresa y saca 'articulo-1.php'

Queue (cola) — FIFO

// Útil para: colas de tareas, impresión, procesos batch
$queue = new SplQueue();
$queue->enqueue('enviar-email-1');  // O(1)
$queue->enqueue('enviar-email-2');
$queue->enqueue('enviar-email-3');

$tarea = $queue->dequeue();   // O(1): saca 'enviar-email-1'

Hash Table / Diccionario

// PHP arrays asociativos son hash tables
$usuarios = [
    'paquito' => ['email' => 'p@ej.com', 'rol' => 'admin'],
    'ana'     => ['email' => 'a@ej.com', 'rol' => 'editor'],
];

$rol = $usuarios['paquito']['rol'];  // O(1) — mucho más rápido que buscar en array

Algoritmos de ordenamiento

// Bubble Sort — simple pero O(n²), solo para aprender
function bubbleSort(array $arr): array {
    $n = count($arr);
    for ($i = 0; $i < $n - 1; $i++) {
        for ($j = 0; $j < $n - $i - 1; $j++) {
            if ($arr[$j] > $arr[$j + 1]) {
                [$arr[$j], $arr[$j + 1]] = [$arr[$j + 1], $arr[$j]];
            }
        }
    }
    return $arr;
}

// En PHP, usa sort() nativo — implementa Timsort (O(n log n))
$nums = [64, 34, 25, 12, 22, 11, 90];
sort($nums);
print_r($nums);  // [11, 12, 22, 25, 34, 64, 90]

Búsqueda binaria

// Requiere array ORDENADO. O(log n) vs O(n) de búsqueda lineal
function busquedaBinaria(array $arr, int $target): int {
    $izq = 0;
    $der = count($arr) - 1;

    while ($izq <= $der) {
        $mid = intdiv($izq + $der, 2);

        if ($arr[$mid] === $target) return $mid;
        if ($arr[$mid] < $target)   $izq = $mid + 1;
        else                         $der = $mid - 1;
    }
    return -1;  // no encontrado
}

$ips_ordenadas = [100, 110, 120, 130, 140, 150];
echo busquedaBinaria($ips_ordenadas, 130);  // índice 3

"Escribir código que funciona es el primer nivel. Escribir código que escala es el segundo. Los algoritmos son el puente entre ambos."