Well, let's break it down to something simpler. Let's just learn merge. Merge is a function that takes as input two already-sorted lists and returns as output a new list with all of the elements of the input lists, also sorted. For example, merge([2,4,6],[3,5]) returns [2,3,4,5,6]. Can you write that function? More on reddit.com

The "merge" operation of merge sort takes two halves of an array, each of which has previously been sorted separately, and merges them together into a single sorted array. For example, given the two subarrays {3, 5, 11, 17} and {4, 8, 9, 20}, the merge operation will build a single array by choosing 3 from the first subarray, then 4 from the second, then 5 from the first, then 8 and 9 from the second, then 11 and 17 from the first, and then 20 from the second to produce the sorted array {3, 4, 5, 8, 9, 11, 17, 20}. So, if you have this merge operation and you want to sort an array, what do you do? Well, you sort the first half of the array, then you sort the second half of the array, and then you merge the two sorted halves together. Now, how do you sort each of the two halves of the array? For instance, how do you sort the first half? Well, you do it the same way: you sort the first subarray by splitting that into two halves, sorting each half, and then merging the two halves together. How do you sort the first half of that? The same way: split it into two halves, sort each half, and then merge them together. So you're splitting, splitting, splitting the array into smaller and smaller pieces. Eventually you get to a point where you've split the array into such small pieces that the thing you have to do is to sort an array of length 1. But that's easy—an array of length 1 is already sorted. Example: Use merge sort to sort the array {11, 28, 10, 19, 5, 21, 16, 14}. Sort the first half: {11, 28, 10, 19}. Sort the first half: {11, 28}. Sort the first half: {11}. This is an array of length 1, so it is already sorted. Sort the second half: {28}. This is an array of length 1, so it is already sorted. Merge the two sorted arrays together: merge {11} and {28} to get {11, 28}. Sort the second half: {10, 19}. Sort the first half: {10}. This is an array of length 1, so it is already sorted. Sort the second half: {19}. This is an array of length 1, so it is already sorted. Merge the two sorted arrays together: merge {10} and {19} to get {10, 19}. Merge the two sorted arrays together: merge {11, 28} and {10, 19} to get {10, 11, 19, 28}. Sort the second half: {5, 21, 16, 14}. Sort the first half: {5, 21}. Sort the first half: {5}. This is an array of length 1, so it is already sorted. Sort the second half: {21}. This is an array of length 1, so it is already sorted. Merge the two sorted arrays together: merge {5} and {21} to get {5, 21}. Sort the second half: {16, 14}. Sort the first half: {16}. This is an array of length 1, so it is already sorted. Sort the second half: {14}. This is an array of length 1, so it is already sorted. Merge the two sorted arrays together: merge {16} and {14} to get {14, 16}. Merge the two sorted arrays together: merge {5, 21} and {14, 16} to get {5, 14, 16, 21}. Merge the two sorted arrays together: merge {10, 11, 19, 28} and {5, 14, 16, 21} to get {5, 10, 11, 14, 16, 19, 21, 28}. More on reddit.com

Any of the thousands of videos on YouTube about mergesort or the hundreds of textbooks that contain information about it will be superior to some lackluster explanation on here. If you're still confused after that, you should ask a specific question. More on reddit.com

I certainly don't have the code for a merge sort memorized, but I understand the algorithm well enough to reconstruct it if somebody gives me a bit of time. Something like this: Let's see... I remember that it's a recursive divide-and-conquer algorithm, so I guess I'll split the list in half and sort each half. I want to make sure the two halves don't overlap, so the first half will go up to but not including the midpoint, and the second half will have everything from the midpoint onward. Checking through some edge cases like n=0, n=1 and n=2 on paper, I can see that my base case is when n<=1 in which case the list is automatically guaranteed to be sorted, so I can just return it as-is. Otherwise, choosing midpoint=n/2 (with integer division rounding down) guarantees that both halves are non-empty and smaller than the original list, so my recursive subdivision is guaranteed to make progress at each step. Cool. Now, after making recursive calls to sort the two halves, I can assume they're individually sorted, so all I have to do is merge them together and I'm good to go. How does that work again? Well, if I'm building the result in order, then first I need to add the smallest value, which is going to be either the minimum of the first half or the minimum of the second half, whichever is smaller. So I guess I'll compare left[0] and right[0], and then... oh yeah, now I remember that I basically just need to do the same thing in a loop, which means I need two index pointers to keep track of how many elements I've already copied from each list. At every loop iteration, I know I need to copy over whichever of the two "next" elements is smaller, because that's the one that needs to go first. Hmm, what happens if they're equal? I guess if both values are the same, I can just copy both and increment both pointers. Or, actually, I can just copy one of them arbitrarily, and then the other one will automatically get handled by the next iteration. That second option seems slightly simpler, so let's do that. Obviously the loop needs to end sometime... how do I do that? If one pointer hits the end of its array, then I'm in trouble because I don't have two elements to compare. But if that happens, I know the rest of the elements in the other array have to go at the end, because they're larger than the ones I already copied. So I guess I can just stop whenever either pointer exceeds its array bounds, and then check after the main loop to see if I need to copy any elements from the other one. Now I just need to translate that into code and step through it to make sure I didn't forget any edge cases or make any silly off-by-one errors. More on reddit.com