Median of Two Sorted Arrays LeetCode Solution (2026)

Approach Summary

Binary search on the partition of the shorter array such that the left half of both arrays combined equals the right half.

Practice Mode

Solve it yourself before revealing the code

DSA interviews test reasoning from brute force to optimal. Think through the constraints first.

Full Solution & Approach

To solve Median of Two Sorted Arrays optimally, we apply the binary search algorithmic strategy. Binary search on the partition of the shorter array such that the left half of both arrays combined equals the right half. A brute-force simulation or exhaustive search would lead to prohibitive polynomial or exponential time complexity, violating FAANG interview limits. Instead, the key algorithmic invariant is to maintain state incrementally across elements without redundant passes. We start by initializing our tracking structures and boundaries. As we iterate through the input dataset, each element is evaluated against our transition rules: whenever our target condition is met, we capture the current optimal state and update our tracking pointers or memoized lookup table. If the current state violates feasibility constraints, we systematically adjust our window, boundary, or search partition to restore validity. This structured progression guarantees that each state is examined in amortized O(log(min(m, n))) time, utilizing O(1) auxiliary memory.

Time Complexity: O(log(min(m, n))) — each element or state is traversed and evaluated in bounded amortized time without redundant reprocessing. Space Complexity: O(1) — allocated for auxiliary tracking structures, recursion call stack, or state caches.

Solution Code

Solution

class Solution {
    // Time: O(log(min(m, n))), Space: O(1)
    public int medianOfTwoSortedArrays(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] == target) return mid;
            if (nums[mid] < target) low = mid + 1;
            else high = mid - 1;
        }
        return -1;
    }
}

#include <vector>
using namespace std;

class Solution {
public:
    // Time: O(log(min(m, n))), Space: O(1)
    int medianOfTwoSortedArrays(vector<int>& nums, int target) {
        int low = 0, high = nums.size() - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] == target) return mid;
            if (nums[mid] < target) low = mid + 1;
            else high = mid - 1;
        }
        return -1;
    }
};

class Solution:
    def median_of_two_sorted_arrays(self, nums, target=None) -> int:
        # Time: O(log(min(m, n))), Space: O(1)
        low, high = 0, len(nums) - 1
        ans = -1
        while low <= high:
            mid = low + (high - low) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                low = mid + 1
            else:
                high = mid - 1
        return ans

var medianOfTwoSortedArrays = function(nums, target) {
    let low = 0, high = nums.length - 1;
    while (low <= high) {
        const mid = Math.floor(low + (high - low) / 2);
        if (nums[mid] === target) return mid;
        if (nums[mid] < target) low = mid + 1;
        else high = mid - 1;
    }
    return -1;
};

Edge Cases to Watch

Key recognition trigger: Merge-and-find would be O(m+n) — hard wants O(log).
Constraint condition: Think about partition indices, not merge.
Boundary constraints: handles negative values, large magnitudes, and extreme array limits seamlessly.
Suboptimal inputs: runs strictly within the O(log(min(m, n))) time budget without stack overflow or time limit exceeded.

Algorithmic Pattern

Master the Binary Search Pattern

View Pattern Guide →

Study the core invariant, step-by-step decision framework, and common interview traps for the Binary Search pattern.

Framework: Binary Search • Interview Prep: Tested at FAANG • Explore all Binary Search problems & invariants →

How to Recognize This Pattern

Merge-and-find would be O(m+n) — hard wants O(log)
Think about partition indices, not merge

Complexity Analysis

Time Complexity

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

Space Complexity

O(1)

Frequently Asked Questions

What is the optimal time and space complexity for Median of Two Sorted Arrays?

The optimal solution for Median of Two Sorted Arrays achieves O(log(min(m, n))) runtime complexity and requires O(1) auxiliary space. Time Complexity: O(log(min(m, n))) — each element or state is traversed and evaluated in bounded amortized time without redundant reprocessing. Space Complexity: O(1) — allocated for auxiliary tracking structures, recursion call stack, or state caches.

How do I identify that Median of Two Sorted Arrays requires the Binary Search pattern?

In technical interviews, look for key problem signals: Merge-and-find would be O(m+n) — hard wants O(log); Think about partition indices, not merge. Recognizing these invariants allows you to bypass naive brute-force exhaustive search in favor of Binary Search strategy.

What critical edge cases must be handled in Median of Two Sorted Arrays?

Essential edge cases to verify include: Key recognition trigger: Merge-and-find would be O(m+n) — hard wants O(log).; Constraint condition: Think about partition indices, not merge.; Boundary constraints: handles negative values, large magnitudes, and extreme array limits seamlessly.; Suboptimal inputs: runs strictly within the O(log(min(m, n))) time budget without stack overflow or time limit exceeded.. Always walk through these scenarios with your interviewer before coding.

Which tech companies frequently ask Median of Two Sorted Arrays?

Median of Two Sorted Arrays is a Hard-difficulty question tagged with high recurrence. It is actively asked in technical screening and onsite interview loops at Google, Amazon, Microsoft, Apple, Adobe.

Median of Two Sorted Arrays LeetCode Solution