Merge Sort Algorithm in DSA C++

Mental Model

Split the list into halves until each part has one item, then merge parts back together in order.

Analogy: Imagine sorting a deck of cards by splitting it into small piles, sorting each pile, then carefully combining piles back into a sorted deck.

Unsorted array:
[38, 27, 43, 3, 9, 82, 10]
Split into halves:
[38, 27, 43]   [3, 9, 82, 10]
Each half split further until single elements:
[38] [27] [43]   [3] [9] [82] [10]

Dry Run Walkthrough

Input: array: [38, 27, 43, 3, 9, 82, 10]

Goal: Sort the array in ascending order using merge sort

Step 1: Split array into two halves

[38, 27, 43]   [3, 9, 82, 10]

Why: We break the problem into smaller parts to sort easily

Step 2: Split left half into [38] and [27, 43]

[38]   [27, 43]   [3, 9, 82, 10]

Why: Keep splitting until each part has one element

Step 3: Split [27, 43] into [27] and [43]

[38]   [27]   [43]   [3, 9, 82, 10]

Why: Single elements are considered sorted

Step 4: Merge [27] and [43] into sorted [27, 43]

[38]   [27, 43]   [3, 9, 82, 10]

Why: Combine sorted parts maintaining order

Step 5: Merge [38] and [27, 43] into sorted [27, 38, 43]

[27, 38, 43]   [3, 9, 82, 10]

Why: Merge left half fully sorted

Step 6: Split right half [3, 9, 82, 10] into [3, 9] and [82, 10]

[27, 38, 43]   [3, 9]   [82, 10]

Why: Split right half to smaller parts

Step 7: Split [3, 9] into [3] and [9]

[27, 38, 43]   [3]   [9]   [82, 10]

Why: Single elements are sorted

Step 8: Merge [3] and [9] into [3, 9]

[27, 38, 43]   [3, 9]   [82, 10]

Why: Merge sorted small parts

Step 9: Split [82, 10] into [82] and [10]

[27, 38, 43]   [3, 9]   [82]   [10]

Why: Split until single elements

Step 10: Merge [82] and [10] into [10, 82]

[27, 38, 43]   [3, 9]   [10, 82]

Why: Merge sorted parts

Step 11: Merge [3, 9] and [10, 82] into [3, 9, 10, 82]

[27, 38, 43]   [3, 9, 10, 82]

Why: Merge right half fully sorted

Step 12: Merge [27, 38, 43] and [3, 9, 10, 82] into fully sorted [3, 9, 10, 27, 38, 43, 82]

[3, 9, 10, 27, 38, 43, 82]

Why: Final merge produces fully sorted array

Result:

[3, 9, 10, 27, 38, 43, 82]

Annotated Code

DSA C++

#include <iostream>
#include <vector>

using namespace std;

void merge(vector<int>& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    vector<int> L(n1), R(n2);

    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(vector<int>& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

int main() {
    vector<int> arr = {38, 27, 43, 3, 9, 82, 10};
    mergeSort(arr, 0, arr.size() - 1);
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

if (left < right) {

check if current segment has more than one element to split

int mid = left + (right - left) / 2;

find middle index to split array

mergeSort(arr, left, mid);

recursively sort left half

mergeSort(arr, mid + 1, right);

recursively sort right half

merge(arr, left, mid, right);

merge two sorted halves into one sorted segment

while (i < n1 && j < n2) {

compare elements from left and right subarrays to merge in order

arr[k] = L[i]; i++;

take element from left subarray if smaller or equal

arr[k] = R[j]; j++;

take element from right subarray if smaller

while (i < n1) { arr[k] = L[i]; i++; k++; }

copy remaining elements from left subarray if any

while (j < n2) { arr[k] = R[j]; j++; k++; }

copy remaining elements from right subarray if any

Output

3 9 10 27 38 43 82 

Complexity Analysis

Time: O(n log n) because the array is repeatedly split in half (log n splits) and merging takes linear time at each level

Space: O(n) because temporary arrays are used to merge sorted halves

vs Alternative: Compared to simple sorting like bubble sort O(n^2), merge sort is much faster for large data but uses extra space

Edge Cases

empty array

function returns immediately without changes

DSA C++

if (left < right) {

array with one element

function returns immediately as single element is already sorted

DSA C++

if (left < right) {

array with duplicate elements

duplicates are handled correctly and appear in sorted order

DSA C++

if (L[i] <= R[j]) {

When to Use This Pattern

When you need a reliable, fast sorting method that works well on large data and can be implemented recursively, reach for merge sort because it splits and merges efficiently.

Common Mistakes

Mistake: Not handling the base case properly causing infinite recursion
Fix: Add condition to stop recursion when segment size is 1 or 0: if (left < right)

Mistake: Incorrectly merging arrays causing out-of-bound errors
Fix: Use correct indices and copy remaining elements after main merge loop

Summary

It sorts an array by splitting it into halves, sorting each half, and merging them back in order.

Use it when you want a fast, stable sorting algorithm especially for large datasets.

The key insight is breaking the problem into smaller sorted parts and merging them carefully.

Practice

1. What is the main idea behind the Merge Sort Algorithm?

easy

A. Select the smallest element and place it at the beginning

B. Divide the array into halves, sort each half, then merge them

C. Sort the array by repeatedly swapping adjacent elements

D. Build a heap and extract elements in sorted order

Solution

1. Step 1: Understand the divide and conquer approach

   Merge sort splits the array into two halves recursively until single elements remain.

2. Step 2: Merge sorted halves

   It then merges these sorted halves to produce a fully sorted array.

3. Final Answer:

   Divide the array into halves, sort each half, then merge them -> Option B

4. Quick Check:

   Merge Sort = Divide, Sort, Merge [OK]

Hint: Remember: split, sort, then merge [OK]

Common Mistakes:

• Confusing merge sort with bubble sort
• Thinking merge sort swaps adjacent elements
• Mixing merge sort with selection sort

2. Which of the following is the correct way to declare the merge function header in C++ for merge sort?

easy

A. int mergeSort(int arr[], int left, int right);

B. int merge(int arr[], int left, int mid, int right);

C. void mergeSort(int arr[], int left, int right);

D. void merge(int arr[], int left, int mid, int right);

Solution

1. Step 1: Identify the merge function role

   The merge function combines two sorted parts; it does not return a value, so it should be void.

2. Step 2: Check parameter list

   It takes the array and three indices: left, mid, and right to merge subarrays.

3. Final Answer:

   void merge(int arr[], int left, int mid, int right); -> Option D

4. Quick Check:

   Merge function = void with arr and indices [OK]

Hint: Merge combines parts, returns nothing [OK]

Common Mistakes:

• Using int return type for merge
• Confusing merge with mergeSort function
• Wrong parameter order or missing parameters

3. What will be the output of the following code snippet after applying merge sort on the array?

int arr[] = {5, 2, 9, 1};
mergeSort(arr, 0, 3);
for(int i = 0; i < 4; i++) std::cout << arr[i] << " ";

medium

A. 5 2 9 1

B. 9 5 2 1

C. 1 2 5 9

D. 2 1 5 9

Solution

1. Step 1: Apply merge sort on the array

   The array {5, 2, 9, 1} is split and sorted recursively to {1, 2, 5, 9}.

2. Step 2: Print the sorted array

   The for loop prints elements in sorted order: 1 2 5 9.

3. Final Answer:

   1 2 5 9 -> Option C

4. Quick Check:

   Sorted array = 1 2 5 9 [OK]

Hint: Merge sort outputs sorted array ascending [OK]

Common Mistakes:

• Printing original array without sorting
• Confusing merge sort with reverse sort
• Off-by-one errors in indices

4. Identify the error in the following merge sort code snippet:

void merge(int arr[], int left, int mid, int right) {
  int n1 = mid - left;
  int n2 = right - mid;
  int L[n1], R[n2];
  for(int i = 0; i < n1; i++) L[i] = arr[left + i];
  for(int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];
  // merging logic...
}

medium

A. Incorrect calculation of n1 and n2 sizes

B. Wrong indexing in copying elements to L array

C. Using variable-length arrays which is invalid in C++

D. Missing return statement in void function

Solution

1. Step 1: Check size calculations

   n1 = mid - left is missing +1 (should be mid - left + 1) to include the mid element; n2 = right - mid is correct.

2. Step 2: Check copying to L array

   Copying starts at left + i for i < n1, which goes up to mid-1, missing arr[mid].

3. Step 3: Identify the main error

   The error causes wrong indexing/range when copying elements to L array.

4. Final Answer:

   Incorrect calculation of n1 and n2 sizes -> Option A

5. Quick Check:

   Subarray size calculation off by one [OK]

Hint: Check array copy indices carefully [OK]

Common Mistakes:

• Off-by-one errors in subarray sizes
• Using variable-length arrays in C++
• Ignoring void function return type

5. Given an array with many duplicate elements, how can merge sort be adapted to maintain the relative order of equal elements (stable sort)?

hard

A. Always pick the element from the left subarray first when merging equals

B. Always pick the element from the right subarray first when merging equals

C. Swap equal elements randomly during merge

D. Use quicksort instead of merge sort

Solution

1. Step 1: Understand stability in sorting

   A stable sort keeps equal elements in their original relative order.

2. Step 2: Apply stability in merge step

   When merging, if elements are equal, always choose the element from the left subarray first to keep order.

3. Final Answer:

   Always pick the element from the left subarray first when merging equals -> Option A

4. Quick Check:

   Stable merge = left element first on equals [OK]

Hint: Pick left element first on ties to keep order [OK]

Common Mistakes:

• Picking right element first breaks stability
• Random swaps destroy order
• Confusing merge sort with quicksort stability