The next sorting algorithm in this series is the Merge
Sort.
Of the algorithms covered so far, this algorithm comes closest to the
Shell Sort
algorithm.
The reason for this lies in how the comparisons are done in both
algorithms: instead of working on the entire array, both the shell sort
and the merge sort work by breaking the array to sort into smaller
arrays and then sorting those first.

To be more specific, merge sort works by taking an array, breaking it
down to the smallest parts, and then combining these parts. When
combining the parts, there's a good chance that one part can just be
appended to the other, which means that there's one comparison and a
merge to be done. However, when the second part cannot be appended to
the first part, the two parts must be merged together. Here, however,
merge sort has an advantage in that both parts to be merged are already
sorted, which makes the merge easier.

The algorithm looks roughly like this:

- Check if the array contains more than 1 element.
- If yes, break the array into two parts and go back to 1.
- If no, return the array - it is now sorted (there's 1 element in it,
so it's trivially sorted).
- Compare the last element of the first returned array with the first
element of the second return array.
- If the first array element from step 4 is less or equal to the
second array element from step 4, then append the second array on to
the first array.
- If the first array element from step 4 is not less or equal to the
second array element, then merge the two arrays.
- Return the appended/merged array - it is now sorted.

The sub-part - the merging function - looks as follows:

- Initialize an empty array.
- Check if both arrays to merge have elements. If not, skip to 4.
- Compare the first elements of both arrays. Remove the lower one from
it's array and append it to the result array. Continue from 2.
- If either array to be sorted still has elements left, append it to
the result array.
- Return the result array - it's a sorted merge of the two provided
arrays.

As can be gathered from this description, there are two parts to the
algorithm: a recursive function, that breaks up the provided array into
ever smaller parts, before recombining them, and a merge function, that
sorts and merges the arrays to be recombined.

## The Code

<?php
class MergeSort extends BaseSort
{
public function sortFunction()
{
$this->store = $this->breakdownArray($this->store);
}
public function breakdownArray(array $array)
{
$count = count($array);
if ($count > 1)
{
$half = $count / 2;
$left = $this->breakdownArray(array_slice($array, 0, $half));
$right = $this->breakdownArray(array_slice($array, $half));
if (end($left) < reset($right))
{
return array_merge($left, $right);
}
else
{
return $this->arraySortMerge($left, $right);
}
}
else
{
return $array;
}
}
public function arraySortMerge(array $left, array $right)
{
$return = array();
$count_left = count($left);
$count_right = count($right);
$l = $r = 0;
while ($l < $count_left && $r < $count_right)
{
if ($left[$l] <= $right[$r])
{
$return[] = $left[$l];
$l++;
}
else
{
$return[] = $right[$r];
$r++;
}
}
if ($l < $count_left)
{
return array_merge($return, array_slice($left, $l));
}
else
{
return array_merge($return, array_slice($right, $r));
}
}
}

Here the structure of the algorithm should be clear: the recursive
function at the top, then the merge function below.

The most important part to optimize in this algorithm is the merge
function - this is where most of the time in the sorting will be spent.
When I wrote up the algorithm, this was the hardest part to create: a
function that merges two already sorted arrays and takes advantage of
this fact. First, I considered extracting the first variables of the
arrays, and then reinsert the one not used (only one variable at a time
should be append to the result array, the other should be checked again
next loop). This was much slower than what the algorithm should run
like, so I went over it a couple of times, trying to improve. The next
version took advantage of the
array_shift
function - this function shifts out the first element of an array and
then reorders the array, so the new first element can be reference via
\$array[0]. This improved the speed of the algorithm by a factor 10, but
it was still running very slow. In fact, the algorithm was running at
O(n^2^) and not the O(n log n) it should. So, I went back to the code
and rethought things: instead of changing the array, it might be faster
to just use indexes for the merge - which indeed was the case. The code
you can see above actually runs in much better time - it's in O(n log n)
now.

The moral should be clear: if you're doing algorithms like this and
you'll be throwing a lot of data after them, you need to do as little
modifying to data structures as possible. Creating a new array by
appending elements doesn't take a lot of time, but shifting elements out
of one and reordering it will.

There's another lesson to be learned as well: the algorithm was running
in O(n2) even with a proper merge function! So, while in theory the
worst case scenario of merge sort is O(n log n) this very much depends
upon the implementation.

## Results

At 1,000 elements

1000 elements to sort.Sanity check. PHP native sort() algorithm took: 0.002649 seconds. Memory used: 48264 bytes
Running MergeSort sort. Algorithm took: 0.022447 seconds. Memory used: 48264 bytes

This is pretty good time, less than 10 times slower than PHP itself.
Next, 10,000 elements:

10000 elements to sort.
Sanity check. PHP native sort() algorithm took: 0.035824 seconds. Memory used: 505704 bytes
Running MergeSort sort. Algorithm took: 0.268344 seconds. Memory used: 505744 bytes

About 11 times slower for 10 times as many elements. 100,000 elements:

100000 elements to sort.
Sanity check. PHP native sort() algorithm took: 0.541093 seconds. Memory used: 4924456 bytes
Running MergeSort sort. Algorithm took: 3.329802 seconds. Memory used: 4924504 bytes

About 12 times slower, at 10 times as many elements. The algorithm is
running steady with running times incrementing as expected for an O(n
log n) sort. Final test, 1,000,000 elements:

1000000 elements to sort.
Sanity check. PHP native sort() algorithm took: 7.504231 seconds. Memory used: 48194472 bytes
Running MergeSort sort. Algorithm took: 41.222942 seconds. Memory used: 48194504 bytes

Sorting one million elements in 41 seconds is not that bad, considering
that the implementation is in PHP, an interpreted language!

Like the shell sort algorithm, this one could actually be used in a
production environment (if you can't use the sort() functions in php).
It's slightly faster than the shell sort as well, so we're clearly
moving into the realm of effective algorithms here.