14.1.8. Conclusion and Future Directions

So, merge sort though it is an order n log n sorting algorithm and therefore it is significantly faster than insertion sort or selection sort, it does have some short comes. The main problem with merge sort is that it requires extra space. See, when I take A and B and I merge it into C, it is almost impossible to do this without storing the merge array in a separate place.

Merge sort is an efficient sorting algorithm with a time complexity of O(n log n), which means it performs significantly better than simpler sorting algorithms like insertion sort or selection sort that run in O(n²) time. However, it comes with a drawback: it requires additional space for the merge operation. When we merge two sorted lists into a new list (let's call it C), we need a separate area to store all the elements being combined, which can be a limitation in terms of memory usage.

Imagine you are sorting a large pile of papers into two folders. If you need to keep a third folder to temporarily hold the sorted papers while you are organizing them, this is similar to how merge sort uses extra space. The folders represent the memory required for sorting and merging. Without a third folder, it would be very difficult to keep everything organized!

And of course, the other thing about merge sort which is very difficult to overcome is that it is inherently recursive and I mean there is no way to actually easily make it iterative, because we need to construct the sorted things and then merge them.

The recursive nature of merge sort means that it repeatedly calls itself to sort smaller sections of the list. While this is powerful and allows the algorithm to handle large datasets efficiently, it also means that each recursive call consumes memory and time. This can sometimes lead to stack overflow errors in programming environments where too many recursive calls have been piled up. The need for maintaining the state of each recursive call can create overhead and complexity in handling large datasets.

Think of a recursive process like a tower of blocks. Each time you add a block, you have to keep the entire structure stable. If you keep adding blocks without finding a way to support the weight, the tower collapses. Similarly, in a computer program, if we keep calling functions without an efficient way to handle their combined weight, it can crash. This is why sometimes simpler, iterative solutions may be more manageable.

So, the main reason we need extra space and merge sort, because of the merge operation as we saw in order to combine A and B into a list C in linear time you need extra space. Now, suppose and this the reason this happen is because we could have something like the left side could be say 2, 4, 6 and the right side could be say 1, 3, 5 and now we need to take things some both side.

The need for extra space in merge sort arises from the necessity to create a new list where all elements from lists A and B are combined. This merging process, while linear in time complexity, inherently requires additional storage to ensure all elements are organized. The discussion hints at possibilities for future sorting algorithms that might reduce or eliminate the need for additional space while retaining efficiency.

Imagine a chef preparing a meal that requires ingredients from two different pans. If the chef has to pour everything into a separate bowl before mixing them together, there's an extra bowl that takes up space on the counter. In the future, a more efficient chef might find a way to mix ingredients directly without needing that extra bowl, which would save space and time. Similarly, future sorting algorithms may work towards combining sorted arrays without using additional memory.

--