Find Median from Data Stream - Practice Coding Problems

Find Median from Data Stream - Problem

Imagine you're processing a continuous stream of numbers from a data source, and you need to efficiently find the median at any point in time. The median is the middle value when numbers are arranged in sorted order.

Key Points:

For odd-sized arrays: median is the middle element
For even-sized arrays: median is the average of two middle elements

Examples:

[2,3,4] → median = 3
[2,3] → median = (2 + 3) / 2 = 2.5

Your Task: Design a MedianFinder class that can:

addNum(int num) - Add a number to the data stream
findMedian() - Return the current median of all numbers seen so far

This problem tests your ability to maintain sorted order efficiently while processing streaming data - a common challenge in real-time systems!

Input & Output

example_1.py — Basic Usage

$ Input: MedianFinder mf = new MedianFinder(); mf.addNum(1); mf.findMedian(); // return 1.0 mf.addNum(2); mf.findMedian(); // return 1.5

› Output: [1.0, 1.5]

💡 Note: After adding 1, the median is 1.0. After adding 2, we have [1,2] so median is (1+2)/2 = 1.5.

example_2.py — Multiple Operations

$ Input: mf.addNum(3); mf.findMedian(); // return 2.0 mf.addNum(4); mf.findMedian(); // return 2.5

› Output: [2.0, 2.5]

💡 Note: After adding 3, we have [1,2,3] so median is 2.0. After adding 4, we have [1,2,3,4] so median is (2+3)/2 = 2.5.

example_3.py — Negative Numbers

$ Input: mf.addNum(-1); mf.addNum(-2); mf.findMedian(); // return -1.5

› Output: [-1.5]

💡 Note: With numbers [-2, -1], the median is (-2 + -1) / 2 = -1.5.

Visualization

Tap to expand

Understanding the Visualization

Setup Two Heaps

Create max heap for lower half, min heap for upper half

Add & Balance

Insert numbers maintaining heap balance (size difference ≤ 1)

Quick Median

Median is always at heap tops - constant time access!

Key Takeaway

🎯 Key Insight: Two balanced heaps maintain the median position without full sorting - like having two smart assistants who always know where the middle is!

Time & Space Complexity

Time Complexity

⏱️

O(log n) per operation

Heap operations (insert/extract) take O(log n) time

⚡ Linearithmic

Space Complexity

O(n)

Store all n numbers across two heaps

⚡ Linearithmic Space

Constraints

-10⁵ ≤ num ≤ 10⁵
There will be at least one element in the data structure before calling findMedian
At most 5 × 10⁴ calls will be made to addNum and findMedian
Follow up: If all integer numbers from the stream are in the range [0, 100], how would you optimize it? If 99% of all integer numbers from the stream are in the range [0, 100], how would you optimize it?

Asked in

G Google 47 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses two balanced heaps: a max heap for the smaller half and a min heap for the larger half of numbers. This approach maintains the median elements at heap tops, enabling O(log n) insertion and O(1) median retrieval, making it ideal for streaming data scenarios.

Common Approaches

Approach	Time	Space	Notes
✓ Two Heaps (Optimal)	O(log n) per operation	O(n)	Use two balanced heaps to maintain median position efficiently
Brute Force (Sort Every Time)	O(n log n) per median query	O(n)	Store all numbers in a list and sort completely for each median query

Two Heaps (Optimal) — Algorithm Steps

Maintain max heap (small) for lower half of numbers
Maintain min heap (large) for upper half of numbers
Keep heaps balanced: |small| - |large| ≤ 1
Add numbers to appropriate heap and rebalance
Median is at heap tops

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heaps

MaxHeap (small) for lower half, MinHeap (large) for upper half

Add Numbers

Balance heaps as numbers are added: [1,2,3,4,5]

Find Median

Median is always at heap tops, O(1) retrieval

Code -

solution.c — C

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

#define MAX_SIZE 50000

typedef struct {
    int data[MAX_SIZE];
    int size;
} Heap;

typedef struct {
    Heap maxHeap; // for smaller half
    Heap minHeap; // for larger half
} MedianFinder;

void maxHeapPush(Heap* h, int val) {
    h->data[h->size] = val;
    int idx = h->size++;
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (h->data[parent] >= h->data[idx]) break;
        int temp = h->data[parent];
        h->data[parent] = h->data[idx];
        h->data[idx] = temp;
        idx = parent;
    }
}

int maxHeapPop(Heap* h) {
    int result = h->data[0];
    h->data[0] = h->data[--h->size];
    int idx = 0;
    while (true) {
        int left = 2 * idx + 1, right = 2 * idx + 2, largest = idx;
        if (left < h->size && h->data[left] > h->data[largest]) largest = left;
        if (right < h->size && h->data[right] > h->data[largest]) largest = right;
        if (largest == idx) break;
        int temp = h->data[idx];
        h->data[idx] = h->data[largest];
        h->data[largest] = temp;
        idx = largest;
    }
    return result;
}

void minHeapPush(Heap* h, int val) {
    h->data[h->size] = val;
    int idx = h->size++;
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (h->data[parent] <= h->data[idx]) break;
        int temp = h->data[parent];
        h->data[parent] = h->data[idx];
        h->data[idx] = temp;
        idx = parent;
    }
}

int minHeapPop(Heap* h) {
    int result = h->data[0];
    h->data[0] = h->data[--h->size];
    int idx = 0;
    while (true) {
        int left = 2 * idx + 1, right = 2 * idx + 2, smallest = idx;
        if (left < h->size && h->data[left] < h->data[smallest]) smallest = left;
        if (right < h->size && h->data[right] < h->data[smallest]) smallest = right;
        if (smallest == idx) break;
        int temp = h->data[idx];
        h->data[idx] = h->data[smallest];
        h->data[smallest] = temp;
        idx = smallest;
    }
    return result;
}

MedianFinder* medianFinderCreate() {
    MedianFinder* obj = (MedianFinder*)malloc(sizeof(MedianFinder));
    obj->maxHeap.size = 0;
    obj->minHeap.size = 0;
    return obj;
}

void medianFinderAddNum(MedianFinder* obj, int num) {
    if (obj->maxHeap.size == 0 || num <= obj->maxHeap.data[0]) {
        maxHeapPush(&obj->maxHeap, num);
    } else {
        minHeapPush(&obj->minHeap, num);
    }
    
    // Rebalance
    if (obj->maxHeap.size > obj->minHeap.size + 1) {
        minHeapPush(&obj->minHeap, maxHeapPop(&obj->maxHeap));
    } else if (obj->minHeap.size > obj->maxHeap.size + 1) {
        maxHeapPush(&obj->maxHeap, minHeapPop(&obj->minHeap));
    }
}

double medianFinderFindMedian(MedianFinder* obj) {
    if (obj->maxHeap.size > obj->minHeap.size) {
        return (double)obj->maxHeap.data[0];
    } else if (obj->minHeap.size > obj->maxHeap.size) {
        return (double)obj->minHeap.data[0];
    } else {
        return (obj->maxHeap.data[0] + obj->minHeap.data[0]) / 2.0;
    }
}

int main() {
    MedianFinder* mf = medianFinderCreate();
    medianFinderAddNum(mf, 1);
    printf("%.1f\n", medianFinderFindMedian(mf)); // 1.0
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n) per operation

Heap operations (insert/extract) take O(log n) time

⚡ Linearithmic

Space Complexity

O(n)

Store all n numbers across two heaps

⚡ Linearithmic Space

Constraints

-10⁵ ≤ num ≤ 10⁵
There will be at least one element in the data structure before calling findMedian
At most 5 × 10⁴ calls will be made to addNum and findMedian
Follow up: If all integer numbers from the stream are in the range [0, 100], how would you optimize it? If 99% of all integer numbers from the stream are in the range [0, 100], how would you optimize it?

42.9K Views

High Frequency

~25 min Avg. Time

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

Two Heaps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler