Algoritmos e Estruturas de Dados em PHP: Guia Prático para Desenvolvedores Web

Algoritmos e Estruturas de Dados em PHP: da Teoria aos Projetos Reais

Muitos desenvolvedores PHP acreditam que algoritmos e estruturas de dados são assunto para C++ ou Java. No entanto, na prática, entender algoritmos básicos impacta diretamente o desempenho e a escalabilidade de aplicações web. Neste artigo, abordaremos as principais estruturas de dados e algoritmos em PHP com exemplos reais de código que podem ser aplicados imediatamente em seus projetos.

Por que um desenvolvedor PHP precisa conhecer algoritmos?

O PHP é tradicionalmente associado ao desenvolvimento rápido de sites, mas frameworks modernos (Laravel, Symfony) e projetos de alta demanda exigem gerenciamento eficiente de dados. Sem entender algoritmos, você corre o risco de:

• Escrever consultas lentas ao banco de dados que poderiam ser substituídas por cache com tabelas hash;
• Criar loops ineficientes com complexidade O(n³);
• Perder o controle de memória ao processar grandes arrays.

As estruturas de dados básicas são a base sobre a qual todos os sistemas modernos são construídos. Vamos analisar sua implementação em PHP.

Estruturas de Dados em PHP: Implementação e Exemplos

1. Pilha (Stack) — Princípio LIFO

A pilha funciona pelo princípio "último a entrar, primeiro a sair". Em PHP, é fácil implementá-la usando um array com as funções array_push() e array_pop(). No entanto, para fins didáticos e melhor compreensão, vamos criar uma classe:

<?phpclass Stack {    private array $items = [];

    public function push($item): void {        $this->items[] = $item;    }

    public function pop() {        if ($this->isEmpty()) {            return null;        }        return array_pop($this->items);    }

    public function peek() {        return $this->items[count($this->items) - 1] ?? null;    }

    public function isEmpty(): bool {        return empty($this->items);    }}

// Exemplo de uso$stack = new Stack();$stack->push('Usuário 1');$stack->push('Usuário 2');echo $stack->pop(); // Usuário 2?>

Onde é aplicado: verificação de parênteses em código, desfazer ações (undo), travessia em profundidade de grafos.

2. Fila (Queue) — Princípio FIFO

A fila funciona como uma fila real: primeiro a entrar, primeiro a sair. Usamos array_shift() e array_push():

<?phpclass Queue {    private array $items = [];

    public function enqueue($item): void {        $this->items[] = $item;    }

    public function dequeue() {        if ($this->isEmpty()) {            return null;        }        return array_shift($this->items);    }

    public function isEmpty(): bool {        return empty($this->items);    }}

// Exemplo: processamento de tarefas em segundo plano$queue = new Queue();$queue->enqueue('Enviar email');$queue->enqueue('Gerar relatório');echo $queue->dequeue(); // Enviar email?>

Onde é aplicado: filas de tarefas (Job Queue), processamento de requisições na ordem de chegada, travessia em largura de grafos (BFS).

3. Tabela Hash (Hash Table) — Busca Rápida

Em PHP, arrays associativos são tabelas hash nativas. Mas para entender a mecânica interna, vamos implementar uma versão simples com colisões por encadeamento:

<?phpclass HashTable {    private array $buckets;    private int $size;

    public function __construct(int $size = 10) {        $this->size = $size;        $this->buckets = array_fill(0, $size, []);    }

    private function hash(string $key): int {        return crc32($key) % $this->size;    }

    public function set(string $key, $value): void {        $index = $this->hash($key);        foreach ($this->buckets[$index] as &$item) {            if ($item[0] === $key) {                $item[1]