Merge Sorted Array

Merge Sorted Array - Problem

You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.

Merge nums1 and nums2 into a single array sorted in non-decreasing order.

The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.

Input & Output

Example 1 — Basic Merge

$ Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3

› Output: [1,2,2,3,5,6]

💡 Note: Merge [1,2,3] and [2,5,6] into sorted order. The final merged array is [1,2,2,3,5,6] stored in nums1.

Example 2 — One Empty Array

$ Input: nums1 = [1], m = 1, nums2 = [], n = 0

› Output: [1]

💡 Note: nums2 is empty, so nums1 remains [1] unchanged.

Example 3 — First Array Empty

$ Input: nums1 = [0], m = 0, nums2 = [1], n = 1

› Output: [1]

💡 Note: nums1 has no actual elements (m=0), so the result is just nums2 = [1].

Constraints

nums1.length == m + n
nums2.length == n
0 ≤ m, n ≤ 200
1 ≤ m + n ≤ 200
-10⁹ ≤ nums1[i], nums2[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

M Microsoft 85 f Facebook 72 a Amazon 68 A Apple 45 G Google 38

The key insight is to merge from the end of both arrays to avoid overwriting elements. Use three pointers to compare elements and place the larger one at the current position. Best approach uses three pointers (backwards): Time: O(m+n), Space: O(1)

Common Approaches

✓ Merge and Sort

⏱️ Time: O((m+n) log(m+n)) Space: O(1)

Copy all elements from nums2 to nums1, then sort the entire nums1 array. This ignores the fact that both arrays are already sorted.

Three Pointers (Backwards)

⏱️ Time: O(m+n) Space: O(1)

Start from the end of both arrays and merge backwards into nums1. This avoids overwriting elements and takes advantage of the sorted property.

Merge and Sort — Algorithm Steps

Copy all elements from nums2 to the end of nums1
Sort the entire nums1 array

Visualization

Tap to expand

Step-by-Step Walkthrough

Copy

Copy nums2 elements to end of nums1

Sort

Sort entire array

Result

Final sorted array

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

void solution(int* nums1, int m, int* nums2, int n) {
    // Copy all elements from nums2 to nums1
    for (int i = 0; i < n; i++) {
        nums1[m + i] = nums2[i];
    }
    
    // Sort the entire array
    qsort(nums1, m + n, sizeof(int), compare);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    
    // Read nums1
    fgets(line, sizeof(line), stdin);
    int nums1[200];
    int nums1_size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums1[nums1_size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    // Read m
    fgets(line, sizeof(line), stdin);
    int m = atoi(line);
    
    // Read nums2
    fgets(line, sizeof(line), stdin);
    int nums2[100];
    int nums2_size = 0;
    token = strtok(line, "[],\n");
    while (token != NULL) {
        nums2[nums2_size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    // Read n
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    solution(nums1, m, nums2, n);
    
    printf("[");
    for (int i = 0; i < nums1_size; i++) {
        printf("%d", nums1[i]);
        if (i < nums1_size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m+n) log(m+n))

Copying takes O(n) time, sorting takes O((m+n) log(m+n)) time

⚡ Linearithmic

Space Complexity

O(1)

Only modifying the input array in-place

✓ Linear Space

892.0K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Merge and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler