Median of Two Sorted Arrays - Practice Coding Problems

Median of Two Sorted Arrays - Problem

You are given two sorted arrays nums1 and nums2 of sizes m and n respectively. Your task is to find the median of the combined sorted array without actually merging the arrays.

The median is the middle value in a sorted list. If the list has an even number of elements, the median is the average of the two middle numbers.

Challenge: Can you solve this in O(log(m+n)) time complexity? This constraint makes the problem significantly more interesting as it rules out simple merging approaches.

Examples:

nums1 = [1,3], nums2 = [2] → Combined: [1,2,3] → Median: 2.0
nums1 = [1,2], nums2 = [3,4] → Combined: [1,2,3,4] → Median: (2+3)/2 = 2.5

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,3], nums2 = [2]

› Output: 2.00000

💡 Note: Merged array: [1,2,3]. The median is 2.

example_2.py — Even Length

$ Input: nums1 = [1,2], nums2 = [3,4]

› Output: 2.50000

💡 Note: Merged array: [1,2,3,4]. The median is (2 + 3) / 2 = 2.5.

example_3.py — One Empty Array

$ Input: nums1 = [], nums2 = [1]

› Output: 1.00000

💡 Note: Only nums2 has elements. The median is 1.

Visualization

Tap to expand

Understanding the Visualization

Setup

We have two sorted arrays and want to partition them into left and right halves

Binary Search

Use binary search to try different partition points in the smaller array

Calculate Complement

For each partition point i in nums1, calculate corresponding point j in nums2

Validate

Check if max(left_elements) ≤ min(right_elements) across both arrays

Find Median

When valid partition found, median is at the boundary of left and right halves

Key Takeaway

🎯 Key Insight: Instead of finding the median directly, find the perfect partition where all left elements ≤ all right elements. The median lies exactly at this boundary!

Time & Space Complexity

Time Complexity

⏱️

O(log(min(m,n)))

Binary search is performed on the smaller array, giving logarithmic time complexity

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

nums1.length == m
nums2.length == n
0 ≤ m ≤ 1000
0 ≤ n ≤ 1000
1 ≤ m + n ≤ 2000
-10⁶ ≤ nums1[i], nums2[i] ≤ 10⁶
Follow-up: The overall run time complexity should be O(log (m+n))

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22 B ByteDance 18

The optimal solution uses binary search to partition both arrays such that the left halves combined contain exactly half of all elements. By ensuring all left elements are ≤ all right elements, we can find the median at the partition boundary in O(log(min(m,n))) time.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Partition (Optimal)	O(log(min(m,n)))	O(1)	Use binary search to find the optimal partition point in O(log(min(m,n))) time
Two Pointers Without Full Merge	O(m+n)	O(1)	Use two pointers to find median position without storing merged array
Merge and Find Median	O(m+n)	O(m+n)	Merge both arrays completely, then find the median

Binary Search on Partition (Optimal) — Algorithm Steps

Ensure nums1 is the smaller array for efficiency
Binary search on nums1 to find partition point i
Calculate corresponding partition point j in nums2
Check if partition is valid (left elements ≤ right elements)
Adjust binary search bounds based on partition validity
Calculate median from boundary elements when valid partition found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Partition

Binary search chooses a partition point i in the smaller array

Calculate j

Calculate corresponding partition point j in the larger array

Validate Partition

Check if all left elements ≤ all right elements

Adjust or Return

If valid, calculate median; otherwise adjust binary search bounds

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    // Ensure nums1 is the smaller array
    if (nums1Size > nums2Size) {
        int* tempArray = nums1;
        nums1 = nums2;
        nums2 = tempArray;
        
        int tempSize = nums1Size;
        nums1Size = nums2Size;
        nums2Size = tempSize;
    }
    
    int m = nums1Size, n = nums2Size;
    int left = 0, right = m;
    
    while (left <= right) {
        int i = (left + right) / 2;
        int j = (m + n + 1) / 2 - i;
        
        int maxLeft1 = (i == 0) ? INT_MIN : nums1[i - 1];
        int minRight1 = (i == m) ? INT_MAX : nums1[i];
        
        int maxLeft2 = (j == 0) ? INT_MIN : nums2[j - 1];
        int minRight2 = (j == n) ? INT_MAX : nums2[j];
        
        if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
            if ((m + n) % 2 == 1) {
                return (double) max(maxLeft1, maxLeft2);
            } else {
                return (max(maxLeft1, maxLeft2) + min(minRight1, minRight2)) / 2.0;
            }
        } else if (maxLeft1 > minRight2) {
            right = i - 1;
        } else {
            left = i + 1;
        }
    }
    
    return 0.0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(min(m,n)))

Binary search is performed on the smaller array, giving logarithmic time complexity

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

nums1.length == m
nums2.length == n
0 ≤ m ≤ 1000
0 ≤ n ≤ 1000
1 ≤ m + n ≤ 2000
-10⁶ ≤ nums1[i], nums2[i] ≤ 10⁶
Follow-up: The overall run time complexity should be O(log (m+n))

52.4K Views

Very High Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Partition (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler