Find Median from Data Stream

Find Median from Data Stream - Problem

The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value, and the median is the mean of the two middle values.

For example:

For arr = [2,3,4], the median is 3
For arr = [2,3], the median is (2 + 3) / 2 = 2.5

Implement the MedianFinder class:

MedianFinder() initializes the MedianFinder object
void addNum(int num) adds the integer num from the data stream to the data structure
double findMedian() returns the median of all elements so far

Answers within 10⁻⁵ of the actual answer will be accepted.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"], values = [null,1,2,null,3,null]

› Output: [null,null,null,1.5,null,2.0]

💡 Note: Initialize finder, add 1, add 2, find median (1+2)/2=1.5, add 3, find median 2.0

Example 2 — Single Element

$ Input: operations = ["MedianFinder","addNum","findMedian"], values = [null,5,null]

› Output: [null,null,5.0]

💡 Note: With only one element, the median is that element itself

Example 3 — Negative Numbers

$ Input: operations = ["MedianFinder","addNum","addNum","findMedian"], values = [null,-1,-2,null]

› Output: [null,null,null,-1.5]

💡 Note: With -1 and -2, the median is (-1 + -2) / 2 = -1.5

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to use two heaps to partition the data stream into smaller and larger halves. The optimal approach uses a max heap for the smaller half and a min heap for the larger half, maintaining balance so that median queries take O(1) time. Time: O(log n) for addNum, O(1) for findMedian. Space: O(n).

Common Approaches

✓ Binary Search

⏱️ Time: N/A Space: N/A

Brute Force - Sort Every Time

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

Keep all numbers in an unsorted list. When findMedian is called, sort the entire list and return the middle element(s). This approach is simple but inefficient for frequent queries.

Two Heaps - Optimal Solution

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

Maintain two heaps: a max heap for the smaller half of numbers and a min heap for the larger half. Keep the heaps balanced so that their tops represent the median elements. This allows O(log n) insertions and O(1) median queries.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int numbers[100000];
static int size = 0;

void medianFinderInit() {
    size = 0;
}

void addNum(int num) {
    // Insert num in sorted order
    int pos = size;
    while (pos > 0 && numbers[pos - 1] > num) {
        numbers[pos] = numbers[pos - 1];
        pos--;
    }
    numbers[pos] = num;
    size++;
}

double findMedian() {
    if (size % 2 == 1) {
        return (double)numbers[size / 2];
    } else {
        return (numbers[size / 2 - 1] + numbers[size / 2]) / 2.0;
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse operations
    char operations[1000][20];
    int op_count = 0;
    
    char* p = strchr(line1, '[');
    if (p) {
        p++;
        while (*p && *p != ']') {
            if (*p == '"') {
                p++;
                int len = 0;
                while (*p && *p != '"') {
                    operations[op_count][len++] = *p++;
                }
                operations[op_count][len] = '\0';
                op_count++;
                if (*p) p++;
            } else {
                p++;
            }
        }
    }
    
    // Parse values
    int values[1000];
    int val_count = 0;
    int has_value[1000] = {0};
    
    p = strchr(line2, '[');
    if (p) {
        p++;
        while (*p && *p != ']') {
            if (strncmp(p, "null", 4) == 0) {
                has_value[val_count] = 0;
                val_count++;
                p += 4;
            } else if (*p == '-' || (*p >= '0' && *p <= '9')) {
                values[val_count] = atoi(p);
                has_value[val_count] = 1;
                val_count++;
                if (*p == '-') p++;
                while (*p >= '0' && *p <= '9') p++;
            } else {
                p++;
            }
        }
    }
    
    // Execute operations and build result
    printf("[");
    int val_idx = 0;
    
    for (int i = 0; i < op_count; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "MedianFinder") == 0) {
            medianFinderInit();
            printf("null");
        } else if (strcmp(operations[i], "addNum") == 0) {
            if (val_idx < val_count && has_value[val_idx]) {
                addNum(values[val_idx]);
            }
            printf("null");
        } else if (strcmp(operations[i], "findMedian") == 0) {
            double median = findMedian();
            if (median == (int)median) {
                printf("%.1f", median);
            } else {
                printf("%g", median);
            }
        }
        
        val_idx++;
    }
    
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.4K Views

High Frequency

~25 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