Sliding Window Median - Practice Coding Problems

Sliding Window Median - Problem

Sliding Window Median is a challenging problem that combines data streaming with efficient median calculation.

Given an integer array nums and window size k, imagine a sliding window moving from left to right across the array. At each position, you need to find the median of the k numbers currently in the window.

🔍 What's a median?
• For odd-sized windows: the middle element when sorted
• For even-sized windows: average of the two middle elements

Example: If nums = [1,3,-1,-3,5,3,6,7] and k = 3:
• Window [1,3,-1] → sorted: [-1,1,3] → median = 1
• Window [3,-1,-3] → sorted: [-3,-1,3] → median = -1
• Window [-1,-3,5] → sorted: [-3,-1,5] → median = -1

Your task is to return an array containing the median for each window position. This problem tests your ability to efficiently maintain sorted order in a dynamic sliding window.

Input & Output

example_1.py — Basic sliding window

$ Input: nums = [1,3,-1,-3,5,3,6,7], k = 3

› Output: [1.0, -1.0, -1.0, 3.0, 5.0, 6.0]

💡 Note: Window positions and their medians: [1,3,-1]→1, [3,-1,-3]→-1, [-1,-3,5]→-1, [-3,5,3]→3, [5,3,6]→5, [3,6,7]→6

example_2.py — Even-sized window

$ Input: nums = [1,2,3,4,2,3,1,4,2], k = 4

› Output: [2.5, 3.0, 3.0, 3.0, 2.5, 3.0]

💡 Note: Even k means median is average of two middle elements: [1,2,3,4]→(2+3)/2=2.5, [2,3,4,2]→(2+3)/2=2.5, etc.

example_3.py — Single element window

$ Input: nums = [1,4,2,3], k = 1

› Output: [1.0, 4.0, 2.0, 3.0]

💡 Note: When k=1, each element is its own median: window [1]→1, [4]→4, [2]→2, [3]→3

Visualization

Tap to expand

Understanding the Visualization

Initialize Balance

Set up two heaps: left side (max-heap) for smaller values, right side (min-heap) for larger values

Add New Element

Compare incoming element with heap tops and add to appropriate side

Maintain Balance

If one side gets too heavy (size difference > 1), move element to other side

Remove Old Element

Mark outgoing elements for lazy deletion to avoid expensive heap operations

Extract Median

For odd k: take top of larger heap. For even k: average both heap tops

Key Takeaway

🎯 Key Insight: By maintaining two balanced heaps (one for smaller half, one for larger half), we achieve O(1) median access while keeping insertion/deletion at O(log k). The balance is the secret - it ensures median elements are always at the heap tops!

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

n elements, each heap operation takes O(log k)

⚡ Linearithmic

Space Complexity

O(k)

Two heaps store at most k elements total, plus hash map for lazy deletion

✓ Linear Space

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Answers within 10^-5 of actual value will be accepted

Asked in

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

The dual heap approach is optimal with O(n log k) time complexity. Use a max-heap for smaller half and min-heap for larger half of the sliding window. This maintains balance and provides O(1) median access while handling element addition/removal in O(log k) time. Key insight: lazy deletion using a hash map avoids expensive heap reconstruction.

Common Approaches

Approach	Time	Space	Notes
✓ Dual Heaps (Optimal)	O(n log k)	O(k)	Use two heaps to maintain balance and find median efficiently
Brute Force (Sort Each Window)	O(nklog k)	O(k)	Sort each window from scratch to find the median

Dual Heaps (Optimal) — Algorithm Steps

Initialize max-heap (smaller half) and min-heap (larger half)
For each new element: add to appropriate heap and rebalance
When window size exceeds k: remove the leftmost element
Calculate median from heap tops
Use hash map to handle lazy deletion of elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Element

Insert new element into appropriate heap based on comparison

Rebalance

Ensure heap sizes differ by at most 1

Remove Old

Mark outgoing element for lazy deletion

Get Median

Extract median from heap tops in O(1) time

Code -

solution.c — C

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

// Simple implementation using array-based approach for demonstration
// In practice, you'd want to implement proper heaps

typedef struct {
    int* data;
    int size;
    int capacity;
} Heap;

Heap* createHeap(int capacity) {
    Heap* heap = (Heap*)malloc(sizeof(Heap));
    heap->data = (int*)malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

double* medianSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize - k + 1;
    double* result = (double*)malloc(*returnSize * sizeof(double));
    int* window = (int*)malloc(k * sizeof(int));
    
    for (int i = 0; i <= numsSize - k; i++) {
        // Copy window
        for (int j = 0; j < k; j++) {
            window[j] = nums[i + j];
        }
        
        // Sort window
        insertionSort(window, k);
        
        // Calculate median
        if (k % 2 == 1) {
            result[i] = (double)window[k / 2];
        } else {
            result[i] = ((double)window[k / 2 - 1] + window[k / 2]) / 2.0;
        }
    }
    
    free(window);
    return result;
}

int main() {
    int nums[] = {1, 3, -1, -3, 5, 3, 6, 7};
    int returnSize;
    double* result = medianSlidingWindow(nums, 8, 3, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%.1f ", result[i]);
    }
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

n elements, each heap operation takes O(log k)

⚡ Linearithmic

Space Complexity

O(k)

Two heaps store at most k elements total, plus hash map for lazy deletion

✓ Linear Space

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Answers within 10^-5 of actual value will be accepted

52.0K Views

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

Dual Heaps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler