Merge Sort Implementation - Problem

Implement the merge sort algorithm from scratch to sort an array of integers in ascending order.

Your implementation should:

Display the array state at each merge step during the sorting process
Return the final sorted array
Use the divide-and-conquer approach typical of merge sort

The merge sort algorithm works by:

Dividing the array into two halves recursively until single elements remain
Merging the divided arrays back together in sorted order
Combining results to produce the final sorted array

Input & Output

Example 1 — Basic Unsorted Array

$ Input: nums = [6,3,8,2]

› Output: [2,3,6,8]

💡 Note: Merge sort divides [6,3,8,2] into [6,3] and [8,2], sorts each half to [3,6] and [2,8], then merges them into [2,3,6,8]

Example 2 — Already Sorted Array

$ Input: nums = [1,2,3,4]

› Output: [1,2,3,4]

💡 Note: Even though the array is already sorted, merge sort still performs the divide and conquer process, resulting in the same sorted array

Example 3 — Reverse Sorted Array

$ Input: nums = [9,7,5,3,1]

› Output: [1,3,5,7,9]

💡 Note: Worst case input where every merge step requires full comparison, but merge sort still achieves O(n log n) time

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 A Amazon 42 🍎 Apple 30

The key insight is that merge sort uses divide-and-conquer to break the problem into smaller, manageable pieces. By recursively dividing the array until single elements remain, then merging sorted halves, we achieve guaranteed O(n log n) performance. Best approach is classic merge sort with Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force (Selection Sort Style)

⏱️ Time: O(n²) Space: O(1)

For each position, scan through all remaining elements to find the minimum, then swap it to the current position. This mimics what someone might try before learning merge sort.

Classic Merge Sort

⏱️ Time: O(n log n) Space: O(n)

The classic divide-and-conquer merge sort algorithm that splits the array in half until single elements remain, then merges them back in sorted order while displaying each merge step.

Brute Force (Selection Sort Style) — Algorithm Steps

Find minimum element in unsorted portion
Swap it to the front of unsorted portion
Move boundary between sorted and unsorted
Display array state after each swap

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Minimum

Scan unsorted portion for smallest element

Swap

Move minimum to front of unsorted portion

Repeat

Continue with remaining unsorted elements

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void solution(int* nums, int n, int* result) {
    for (int i = 0; i < n; i++) {
        result[i] = nums[i];
    }
    
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (result[j] < result[minIdx]) {
                minIdx = j;
            }
        }
        
        if (minIdx != i) {
            int temp = result[i];
            result[i] = result[minIdx];
            result[minIdx] = temp;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [1,2,3] format
    int nums[100], n = 0;
    char* ptr = strchr(line, '[');
    ptr++;
    
    char* token = strtok(ptr, ",]");
    while (token) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result[100];
    solution(nums, n, result);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop runs n times, inner loop averages n/2 comparisons

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for variables

⚡ Linearithmic Space

34.0K Views

High Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Merge Sort Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Selection Sort Style) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler