It's been a while since I did the last post (merge sort) in my sorting algorithms in PHP series (new readers start with Sorting algorithms: bubblesort) so I thought it about time that I add the next part. This time I'm going for heap sort. This algorithm has some similarities with merge sort, mainly the recursive nature, the divide and conquer idea: heap sort treats an array like a tree of elements instead of just one big pool of elements. Other than that, like some of the other sort algorithms presented it can be sorted in place, leading to less memory use - however it is not a stable sort, as the elements can quite easily change order.

In details, heap sort works by imposing a hierarchical tree structure on the set of elements and that the structure satisfies the heap requirement: that any given node be of equal to or less value than it's parent. This is actually only a requirement for one type of heaps, the max-heaps - the other type, min-heaps, work in the opposite way, namely by having a parent node be always equal to or less than a child node. The reason this is significant is that you will always know which element is the largest: it's the root node (in a max-heap, still). Hence, if we have a heap in proper order, we can then take the root node out of the heap and put it at the end of the array to sort. After bringing the heap in order again, we can repeat this, popping off the next largest element and putting it at the second to last position in the array.

Laying it out in steps, it looks like:

- heapify array
- pop root element off and store at end of array
- heapify remaining heap
- repeat step 2-3 while constantly moving one step back when storing popped element

And that's it! Well, it obviously gets a bit harder once you get into the details - and without those, no sorting :) As with merge sort, it's the recursive function that's most important to the algorithm: the heapify thing. This is where the time will be spent so this is where it's most important that things are optimized and that the algorithm works out.

So how does the heapify function work? It's rather simple: it compares a node with it's two leaves and if one of the is (or both are) larger than the root a swap is made - the largest leaf takes the place of the root node and vice versa. Because of the hierarchical structure of the heap, every node can have at most two leaves. If a swap is made, the heapify function recursively calls itself with the index of the swapped out leaf (the previous root, now a leaf) because this may now be a new root node in another local heap which then has to be checked. If on the other hand a swap is not made the heapify function simply returns: the heap is in order.

In terms of sorting, this means that you first heapify the array once and then of course once per element you pop off the array. As the algorithm swaps out the root node (the one to be popped off the heap) with the last leaf in the array the heapify function then has to be called to get the heap back into shape. Because the last element of the heap is smaller than any of it's ancestors, the heapify function will recursively call itself a maximum of log~2~(n)-1 times. As the heap grows smaller, the number of recursions drops but this obviously happens on a log~2~ scale as well so this is not a major factor in the speed - the biggest speed factor lies in a combination of the fact that sorting a heap when a new root is introduced, given that the heap has previously been heapified, only takes log~2~(n) moves and that the first heapification of an array is quite fast too.

Enough talk, now code.

## The Code

```
<?php
class HeapSort extends BaseSort
{
public function sortFunction()
{
$array = $this->store;
$heap_length = count($array);
$this->buildHeap($array, $heap_length);
while ($heap_length)
{
$temp = $array[0];
$array[0] = $array[$heap_length - 1];
$array[$heap_length - 1] = $temp;
$heap_length--;
$this->heapify($array, 1, $heap_length);
}
$this->store = $array;
}
private function buildHeap(&$array, $heap_length)
{
for ($i = floor($heap_length / 2); $i > 0; $i--)
{
$this->heapify($array, $i, $heap_length);
}
}
private function heapify(&$array, $index, $heap_length)
{
$largest = $index;
$comp = $array[$largest-1];
$r = $index << 1;
$l = $r++;
if (($l <= $heap_length) && ($array[$l-1] > $comp))
{
$largest = $l;
$comp = $array[$l-1];
}
if (($r <= $heap_length) && ($array[$r-1] > $comp))
{
$largest = $r;
$comp = $array[$r-1];
}
if ($largest != $index)
{
$temp = $array[$index-1];
$array[$index-1] = $comp;
$array[$largest-1] = $temp;
$this->heapify($array, $largest, $heap_length);
}
}
}
```

Quick walkthrough: first, the heap is built (or rather, the array is treated like a heap that's out of order) after which the main loop is entered. Here, with each iteration, the root node is popped of the array (shifted, in PHP terms) and the heap is heapified again. The main action takes part in the heapify() method: it's called with the heap, the index of the node to heapify and the length of the heap. The method checks the indexed node against it's leaves and if any of them are larger than it a swap is made and the method is called recursively.

I've experimented a bit with optimizing the code and the version above is the fastest I've got it to. The biggest payoffs came from passing the array by reference instead of using a property of the class as well as passing the array length into functions - I hadn't expected either to be a speed improvement but going that way shaved off 5 (five) seconds of the running time when sorting 100,000 elements. Which, I guess, leads me to the results.

## Results

```
1000 elements to sort.
Sanity check. PHP native sort() algorithm took: 0.000878 seconds. Memory used: 64360 bytes
Running Heapsort sort. Algorithm took: 0.089941 seconds. Memory used: 64360 bytes
```

At 1,000 elements the algorithm it's running in about 1.25 times the time of the merge sort implementation I made.

```
10000 elements to sort.
Sanity check. PHP native sort() algorithm took: 0.012138 seconds. Memory used: 665804 bytes
Running Heapsort sort. Algorithm took: 1.208370 seconds. Memory used: 665800 bytes
```

At 10,000 elements it's running in 1.5 times the merge sort - pretty good but not quite the same.

```
100000 elements to sort.
Sanity check. PHP native sort() algorithm took: 0.222491 seconds. Memory used: 6524576 bytes
Running Heapsort sort. Algorithm took: 14.997653 seconds. Memory used: 6524560 bytes
```

With 100,000 elements the pattern is fairly clear in terms of how the algorithm is doing - a bit less than a straight O(n log n). Final test is 1,000,000 elements.

```
1000000 elements to sort.
Sanity check. PHP native sort() algorithm took: 3.602368 seconds. Memory used: 64194572 bytes
Running Heapsort sort. Algorithm took: 188.843620 seconds. Memory used: 64194576 bytes
```

Increasing the number of elements to sort by an order of magnitude increases the run time by 12.5 - which is pretty good (compare to the internal PHP algorithm which increases by a factor 15).