## Data structures, Merge sort

Merge sort is one of those algorithms that we kind of use everyday (most of the time indirectly or in a modified version) and we probably don’t think about it. As I mentioned previously quicksort is kind of the facto sorting algorithm in many of standard library implementations in many languages but surprisingly Merge sort is there as well. This is another divide and conquer and recursive algorithm, and the idea is extremely simple:

You divide a list until they are sorted (one element) and then merge them back while sorting them

So at the end what you do is to divide into smallest sublist and when merging you take care of sorting them back. In pseudocode it looks very familiar to the previous quick sort:

```
function merge_sort(items, lo, hi)
if low < hi then
mid = lo + floor((lo + hi) / 2)
merge_sort(items, lo, mid)
merge_sort(items, mid + 1, lo)
merge(items, lo, mid, hi)
end
end
```

Again, converting this into Kotlin is simple enough:

```
fun <T: Comparable<T>> mergeSort(items: MutableList<T>, low: Int = 0, high: Int = items.size - 1) {
if (low >= high) return
val mid = low + (high - low) / 2
mergeSort(items, low, mid)
mergeSort(items, mid + 1, low)
// This is where magic happens!
}
```

This is one specific thing I dislike from quicksort and merge sort, the real *core* of the algorithm is *always* hidden in some magic box, in quicksort was the `partition`

section, here is the `merge`

section. The guarantee is to take both divisions (or halves) and merge them back *but in sorted order* and I remembered for me that was like “oh yeah, do you want fries with that?”.

The easiest way is using an intermediary array, you see, we take both arrays (or array sections) and create a third array that will fit both arrays in memory and then place the sorted items there, sadly, with really big list you will have to deal with a lot of space (we will see more about this later), thanks to the great book (Algorithms by R. Sedgewick) I saw a very clever way to do the merge in a very easy way to understand (compared with other books I had read about it):

```
function merge(items, lo, mid, hi)
i = lo
j = mid + 1
aux = []
for k = lo to hi
aux[k] = items[k]
end
for k = lo to hi
if i > mid then
items[k] = aux[j++]
end
if i > hi then
items[k] = aux[i++]
end
if aux[j] < aux[i] then
items[k] = aux[j++]
else
items[k] = aux[i++]
end
end
end
```

In this case we copy the data from the gap between low to high into an intermediary array and then go through the whole segment and checking against the current value using two pointers, one for each of the sides of the merge operation (that is what we see in that huge switch statement). Now with this implementing the merge operation in Kotlin is a piece of cake!

```
fun <T : Comparable<T>> mergeSort(items: MutableList<T>, lo: Int = 0, hi: Int = items.size - 1) {
fun merge(lo: Int, hi: Int, mid: Int) {
var a = 0;
var b = (hi - mid) // b is the middle point of the collection
val aux = items.slice(lo..hi) // We copy the part we need to sort
for (idx in lo..hi) {
items[idx] = when {
a >= (hi - mid) -> aux[b++] // No remaining elements in the left side
b >= aux.size -> aux[a++] // No remaining elements in the right side
aux[a] < aux[b] -> aux[a++]
else -> aux[b++]
}
}
}
if (hi <= lo) return // No elements to process, list already sorted!
val mid = lo + (hi - lo) / 2
mergeSort(items, lo, mid)
mergeSort(items, mid + 1, hi)
merge(lo, hi, mid)
}
```

Notice I am not marking the function `tailrec`

because, well, it is not tail recursive. The `when`

clause could be heavily simplified but I preferred to leave it like that so it is a lot clearer how the sorting process is done (it actually took me a while to digest and write the code but it felt good getting there by myself). As you see there is a big problem with our merge sort, we have to create an array of the size of the collection we are sorting, can you figure out why? (go, think about it).

Because we split the sorting collection in half all the time, the time performance of merging sort is pretty good, \(\mathcal{O}(n \log{n})\), but at a high cost (temporary memory) for big collections. There is a big exception for all of this though, this algorithm becomes extremely memory efficient when dealing with linked lists (remember our friends linked lists?), in fact, this is the algorithm used by things like the Linux kernel to sort linked lists (because its efficiency with them). Go and try to write a version to sort linked lists instead of this array version, you will see what I am talking about.

There is *another* way to write this sorter, besides using a linked list, and use a full recursive implementation passing lists and generating a new list all the time. It is actually a lot easier than this implementation, maybe in another blog post I will examine this case.

This was, for me, the hardest of all the sorting algorithms to write, I can’t exactly tell you why, maybe it is the easiest for you, go and try writing it by yourself in your favourite programming language!