# Merge sort in 3 minutes

## Table of Contents

## Introduction

This tutorial provides a step-by-step guide to understanding and implementing the merge sort algorithm. Merge sort is a highly efficient sorting algorithm that uses the divide-and-conquer approach, making it a fundamental technique in computer science and programming. This guide will help you grasp the process of merge sorting through clear instructions and practical coding examples.

## Step 1: Understand the Merge Sort Algorithm

Before implementing merge sort, it's essential to understand how it works.

**Divide**: The array is recursively divided into two halves until each half contains a single element.**Conquer**: Each half is then sorted and merged back together.**Combine**: The sorted halves are combined to produce the final sorted array.

### Practical Tip

Visualizing the process can be very helpful. You can draw a binary tree to represent the splitting of the array into halves.

## Step 2: Implement the Merge Function

The merge function is crucial as it combines two sorted arrays into one sorted array.

- Create a function called
`merge`

that takes two sorted arrays as input. - Initialize an empty array to hold the merged results.
- Use two pointers to track the current index of each array.
- Compare elements from both arrays and add the smaller element to the merged array.
- Once one array is exhausted, append the remaining elements from the other array.

### Example Code

```
def merge(left, right):
merged = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
merged.append(left[i])
i += 1
else:
merged.append(right[j])
j += 1
merged.extend(left[i:])
merged.extend(right[j:])
return merged
```

## Step 3: Implement the Merge Sort Function

Now that you have the merge function, it's time to implement the merge sort algorithm itself.

- Create a function called
`merge_sort`

that takes an array as input. - Base case: If the array has one or no elements, return it (it's already sorted).
- Recursively split the array into two halves.
- Sort each half by calling
`merge_sort`

on them. - Merge the sorted halves using the
`merge`

function.

### Example Code

```
def merge_sort(array):
if len(array) <= 1:
return array
mid = len(array) // 2
left_half = merge_sort(array[:mid])
right_half = merge_sort(array[mid:])
return merge(left_half, right_half)
```

## Step 4: Test the Merge Sort Implementation

To ensure your implementation works correctly, you should test it with various input arrays.

- Create test cases with different scenarios:
- An already sorted array.
- An array in reverse order.
- An array with duplicate elements.

- Print the output of the
`merge_sort`

function for each test case.

### Example Test Code

```
if __name__ == "__main__":
unsorted_array = [38, 27, 43, 3, 9, 82, 10]
sorted_array = merge_sort(unsorted_array)
print(sorted_array) # Output: [3, 9, 10, 27, 38, 43, 82]
```

## Conclusion

In this tutorial, you learned about the merge sort algorithm, including how to implement both the merge and merge sort functions. You also explored how to test the implementation with different scenarios.

Next steps could include:

- Trying to optimize the algorithm further.
- Implementing merge sort in different programming languages.
- Exploring other sorting algorithms for comparison.

For further reading, you can check the provided resources to deepen your understanding of merge sort and sorting algorithms in general.