### Executive Summary

This comprehensive guide takes an exhaustive look at the merge sort algorithm - a fundamental sorting method in computer science, and specifically within data structures and algorithms. We delve into its workings, properties, complexities, and implementation, methodically building upon concepts to cater to a broad spectrum of readers, from beginners to seasoned professionals. We expound on auxiliary concepts like divide and conquer strategy, time and space complexities, iterative and recursive approaches, and the algorithm's relevancy in parallel computing. In connecting the dots, we will also look at the underpinnings of merge sort's C++ implementation. We conclude with a unique twist on merge sort's connection to 'External Sorting', where we take a leap from the confines of main memory to the expanse of external storage.

### Introduction

Imagine you are a librarian tasked with sorting thousands of books by their ISBN numbers. The books are scattered in no particular order, and doing this manually would be a tedious and error-prone task. However, if we can devise a strategy to divide the problem into smaller, manageable parts and combine the sorted parts strategically, we can accomplish the task efficiently. This is where the Merge Sort algorithm comes into play.

Merge Sort, conceptualized by John von Neumann in 1945, is a divide-and-conquer algorithm used for sorting a list of elements. Its essence lies in its ability to break a complex problem into simpler subproblems, solve them independently, and merge the solutions to form the final solution. This approach yields a significant reduction in time complexity compared to rudimentary sorting algorithms such as bubble sort or selection sort.

In essence, merge sort works by dividing an unsorted list into N sublists, each containing one element (a list of one element is considered sorted), then repeatedly merging sublists to produce new sorted sublists until there is only one sublist remaining - the sorted list.

### 1. Divide and Conquer Strategy

The divide-and-conquer strategy is the backbone of merge sort. It is a method of solving complex problems by breaking them into smaller, more manageable subproblems until they become simple enough to solve directly. The solutions to the subproblems are then combined to give a solution to the original problem. The strategy involves three steps:

##### 1.1 Divide

The problem is divided into several subproblems that are smaller instances of the same problem. In the context of merge sort, this involves dividing an unsorted list into two halves.

##### 1.2 Conquer

The subproblems are solved independently. In the case of merge sort, this refers to recursively sorting the two halves of the list.

##### 1.3 Combine

The solutions to the subproblems are combined into a solution for the original problem. In the merge sort algorithm, this involves merging the two sorted halves into one sorted list.

### 2. Time and Space Complexity

The efficiency of an algorithm is generally measured in terms of time and space complexity. In the case of merge sort, both are of significant importance.

##### 2.1 Time Complexity

Time complexity of merge sort in all cases (worst, average, and best) is O(n log n), where n is the number of elements. The log n factor is the depth of the recursion tree (log n divisions), and n is the work done per level of recursion (n comparisons).

##### 2.2 Space Complexity

Due to the auxiliary space used for the temporary arrays during the merge process, the space complexity of merge sort is O(n).

### 3. Iterative and Recursive Merge Sort

Merge sort can be implemented iteratively and recursively. Both methods follow the divide and conquer strategy, but their approaches differ.

##### 3.1 Recursive Merge Sort

Recursive merge sort repeatedly breaks down the list to be sorted into two halves until we reach the base case of a list with one element. The merge process then combines these smaller lists into sorted lists.

```
void merge(int arr[], int l, int m, int r)
{
// Merge function code
}
void mergeSort(int arr[], int l, int r)
{
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
```

##### 3.2 Iterative Merge Sort

Iterative merge sort does not involve recursion. Instead, it uses loops to perform sorting. It starts by sorting pairs of elements far apart from each other, then progressively reducing the gap between elements to be compared.

```
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
/* create temp arrays */
int L[n1], R[n2];
/* Copy data to temp arrays L[] and R[] */
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
/* Merge the temp arrays back into arr[l..r]*/
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
/* Copy the remaining elements of L[], if there
are any */
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
/* Copy the remaining elements of R[], if there
are any */
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
/* l is for left index and r is right index of the sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l+(r-l)/2; //Same as (l+r)/2 but avoids overflow for large l & h
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
```

### 4. Merge Sort in Parallel Computing

Merge sort's divide and conquer strategy lends itself well to parallel computing. Each divide step can spawn a new thread or process, making merge sort an optimal choice for multi-threaded and multi-processor systems. The efficiency of parallel merge sort, however, is tied to the overhead of thread/process creation and inter-thread or inter-process communication. Furthermore, it allows for better utilization of memory hierarchy, making it suitable for large data sets.

### 5. Relevance of Merge Sort

Merge sort is particularly efficient for large data sets, outperforming algorithms like quicksort and heapsort for data sets that don't fit in memory. This property is critical in fields like databases or file systems where data is stored in disk blocks. Merge sort is also stable, meaning it maintains the relative order of equal sort keys, which is beneficial when dealing with complex data structures or secondary keys. Furthermore, its inherent parallel nature makes it ideal for multi-processor and multi-core systems.

### 6. Connecting Merge Sort with External Sorting

In the realm of databases and file systems, data often exceeds the size of main memory and resides in external storage. An example is sorting a billion numbers using a machine that has memory to store only a thousand numbers at a time. This scenario brings us to a specialized topic known as 'External Sorting', where sorting algorithms work with data that cannot fit into a computer's main memory. A popular method in external sorting is the 'External Merge Sort', an extension of the merge sort algorithm. The connection here provides an engaging perspective on how a classical sorting algorithm adapts to modern computing challenges, a topic we will dive into in our subsequent exploration.

### Conclusion

Stepping back to look at the bigger picture, merge sort is much more than a sorting algorithm. It is an exemplification of the divide and conquer strategy, a testament to recursive problem-solving, and a model for parallel computing. Its stability and efficiency with large data sets give it a significant role in various domains, including databases and file systems. As we traverse from main memory to external storage, the story of merge sort continues, adapting and evolving to meet modern computing challenges. So let's embark on this journey of exploration, where we unveil the 'External Merge Sort' in our next expedition.