PHP SPL data structures are underused — SplMinHeap practical example

tobw13 May 2026 16:38

Most PHP developers use plain arrays for everything and miss out on SPL structures that are significantly faster for specific use cases. SplMinHeap is one I wish I had known about years earlier.

Classic use case: priority queue, top-N elements, Dijkstra-like algorithms.

PHP
<?php
// Task scheduler: always process the task with the lowest priority number first
class Task
{
public function __construct(
public readonly string $name,
public readonly int $priority,
) {}
}
$heap = new SplMinHeap();
// Add tasks in random order
$heap->insert([1, new Task('Send email', priority: 5)]);
$heap->insert([2, new Task('Critical alert', priority: 1)]);
$heap->insert([3, new Task('Generate report', priority: 3)]);
$heap->insert([4, new Task('Cleanup logs', priority: 8)]);
$heap->insert([5, new Task('DB backup', priority: 2)]);
// SplMinHeap extracts the minimum first
echo "Processing order:\n";
while (!$heap->isEmpty()) {
[$_, $task] = $heap->extract();
printf(" [priority %d] %s\n", $task->priority, $task->name);
}
// Output:
// [priority 1] Critical alert
// [priority 2] DB backup
// [priority 3] Generate report
// [priority 5] Send email
// [priority 8] Cleanup logs
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

For top-N from a large dataset without sorting the whole thing:

PHP
<?php
function topN(array $values, int $n): array
{
$heap = new SplMinHeap();
foreach ($values as $v) {
$heap->insert($v);
if ($heap->count() > $n) {
$heap->extract(); // remove the smallest
}
}
$result = [];
while (!$heap->isEmpty()) {
$result[] = $heap->extract();
}
return array_reverse($result);
}
$data = array_map(fn() => rand(1, 1000), range(1, 10000));
$top5 = topN($data, 5);
echo "Top 5: " . implode(', ', $top5) . "\n";
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0
1849
Replies (2)
mikeb13 May 2026 16:57

Good examples. SplStack and SplQueue are also worth knowing. SplStack is LIFO and much stricter than using an array with array_push/array_pop — it enforces the interface so you do not accidentally do random access.

PHP
<?php
// Depth-first traversal of a tree using explicit stack (no recursion)
$tree = [
1 => [2, 3],
2 => [4, 5],
3 => [6],
4 => [],
5 => [],
6 => [],
];
$stack = new SplStack();
$visited = [];
$stack->push(1);
while (!$stack->isEmpty()) {
$node = $stack->pop();
if (in_array($node, $visited)) continue;
$visited[] = $node;
echo "Visited: $node\n";
foreach (array_reverse($tree[$node]) as $child) {
$stack->push($child);
}
}
// Visits: 1, 2, 4, 5, 3, 6
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0
p_hajek13 May 2026 18:30

The performance difference versus arrays matters at scale. I benchmarked SplMinHeap vs sorting a plain array for finding the top 10 items out of 1 million:

sort() on full array: ~420ms. SplMinHeap with N=10 constraint: ~180ms. The heap avoids sorting elements that will never be in the top N.

For most business logic arrays are fine and clearer to read. But if you are doing anything that looks like scheduling, pathfinding, or ranking, reach for the right structure.

0
Write a reply
Markdown. ```php blocks are runnable.