13.3.1. Algorithm to Sort Using Merge Sort

So, we have seen two intuitive sorting algorithms; selection sort, and insertion sort, but unfortunately for us, both of them turn out to be order n square. And we know that order n square is not really good enough for sorting large arrays. So, what can we do instead?

In this introduction, the problem with traditional sorting algorithms like selection sort and insertion sort is explained. Both of these algorithms have a time complexity of O(n²), meaning their efficiency decreases significantly with larger arrays. This suggests the need for a more efficient sorting algorithm.

Imagine trying to sort a large pile of books by checking each one against every other book repeatedly. This would take a long time (like O(n²)). Now imagine being able to first divide the books into two separate smaller piles, sorting each one, and then combining them. This approach saves time and is more efficient, which is what merge sort aims to achieve.

So, here is one way to sort an array more effectively. So, suppose we divide the array into two equal parts. So, we just bracket in the middle, we look at the left separately and the right separately. Now assume that we can sort the left and right into independently sorted halves. So, we have the left half sorted, the right half sorted.

The merge sort algorithm starts by dividing the original array into two halves. Each half can be sorted independently. The assumption here is that once we have both halves sorted, we can merge them back together in a sorted order. This division is fundamental to the merge sort approach.

Think of a large group of people at a party who are all mixed up and need to be sorted by their age. Instead of trying to compare everyone at once, you could split the group into two smaller groups based on a central age, sort those individually, and then come back together to merge their information. This makes the sorting process much quicker.

So, let us first look at this combining step. So, we are given two sorted lists a and b or two sorted arrays a and B, and we want to combine them into a single sorted list.

The merging process is a critical part of the merge sort algorithm. Once the array is divided and both halves are sorted, they need to be combined into a single sorted array. The algorithm achieves this by comparing the elements of the two sorted halves and placing the smaller elements into a new list until all elements are sorted.

Imagine you have two sorted stacks of playing cards. You would take the top card from each stack, compare them, and place the smaller one into a new stack until both stacks are empty. This method ensures you keep the order while merging the two stacks.

As we said our aim is to break up the problem into two equal sub problems. Solve the sub problems, and there merge the two solutions into a final solution. So, we will sort a 0 to a n by 2 a n by 2 n minus 1 to make it distinct.

Merge sort utilizes a recursive approach. This means that the sorting function calls itself for the two halves of the array. Each time the array is split into halves and sorted, the process continues until the base case is reached—an array of size one, which is inherently sorted. Then the merging process begins.

Imagine a team working on a large project. They break the project down into smaller tasks (sub-problems), assign those tasks to team members, and then come together to compile their work into a final presentation. Each step operates independently but culminates in a cohesive final product.

The base cases when we have only one element and no sorting is required. We will again split each of these into two parts. So, notice that for convenience we have taken something where I can keep dividing by 2, but there is no limitation in merge sort, it will work for any size.

In merge sort, the recursion continues until it reaches the base case, where an array of size one needs no sorting. This trivial case simplifies the problem because a single element is always in order. Thus, the algorithm can comfortably handle arrays of any size by recursively dividing them until it hits the base case.

Think about peeling an onion. You might take one large onion and cut it in half. Then, if it is still too big, cut those halves again. Eventually, you end up with very small pieces that are easy to handle, just like how merge sort simplifies the sorting process into manageable parts.

Now I want to merge these two arrays into a sorted segment of length 4, and these two arrays it was sorted segment of length 4. So, again apply merging.

After the final sorting is done individually for all the divided parts, the last step is to merge these sorted segments back together into one complete array. Each pair of sorted segments is compared and merged to ensure that the final output array is also sorted.

Recall the playing card example. After sorting the cards from two stacks, if newer players join with their cards, you would repeat the same merging process by comparing with the already sorted cards ensuring everyone's cards are in the right order.

--