Find Median from Running Data Stream

Last Updated : 17 Feb, 2025

Given a data stream arr[] where integers are read sequentially, the task is to determine the median of the elements encountered so far after each new integer is read.

There are two cases for median on the basis of data set size.

If the data set has an odd number then the middle one will be consider as median.
If the data set has an even number then there is no distinct middle value and the median will be the arithmetic mean of the two middle values.

Example:

Input: arr[] = [5, 15, 1, 3, 2, 8]
Output: [5.00, 10.00, 5.00, 4.00, 3.00, 4.00]
Explanation:
After reading 1st element of stream – 5 -> median = 5
After reading 2nd element of stream – 5, 15 -> median = (5+15)/2 = 10
After reading 3rd element of stream – 5, 15, 1 -> median = 5
After reading 4th element of stream – 5, 15, 1, 3 -> median = (3+5)/2 = 4
After reading 5th element of stream – 5, 15, 1, 3, 2 -> median = 3
After reading 6th element of stream – 5, 15, 1, 3, 2, 8 -> median = (3+5)/2 = 4

Input: arr[] = [2, 2, 2, 2]
Output: [2.00, 2.00, 2.00, 2.00]
Explanation:
After reading 1st element of stream – 2 -> median = 2
After reading 2nd element of stream – 2, 2 -> median = (2+2)/2 = 2
After reading 3rd element of stream – 2, 2, 2 -> median = 2
After reading 4th element of stream – 2, 2, 2, 2 -> median = (2+2)/2 = 2

Table of Content

[Naive Approach] Using Insertion Sort

If we can sort the data as it appears, we can easily locate the median (center) element. Insertion Sort is one such online algorithm that sorts the data appeared so far. At any instance of sorting, say after sorting i-th element, the first i elements of the array are sorted. The insertion sort doesn’t depend on future data to sort data input till that point. In other words, insertion sort considers data sorted so far while inserting the next element. This is the key part of insertion sort that makes it an onlinealgorithm.

C++

// C++ program to find Median from Running Data Stream // Using Insertion Sort #include <iostream> #include <vector> #include <iomanip> using namespace std;  // Function to print median of stream of integers vector<double> getMedian(vector<int> &arr) {     vector<double> res;      res.push_back(arr[0]);      for (int i = 1; i < arr.size(); i++) {         int j = i - 1;         int num = arr[i];          // shift elements to right to create space to insert         // the current element at its correct position         while (j >= 0 && arr[j] > num) {             arr[j + 1] = arr[j];             j--;         }         arr[j + 1] = num;                  int len = i + 1;         double median;          // If odd number of integers are read from stream         // then middle element in sorted order is median         // else average of middle elements is median         if (len % 2 != 0) {             median = arr[len / 2];         }         else {             median = (double)(arr[(len / 2) - 1] + arr[len / 2]) / 2;         }          res.push_back(median);     }          return res; }  int main() {     vector<int> arr = {5, 15, 1, 3, 2, 8};     vector<double> res = getMedian(arr);     cout << fixed << setprecision(2);          for (double median: res)          cout << median << " ";     return 0; }

Java

// Java program to find Median from Running Data Stream // Using Insertion Sort import java.util.ArrayList; import java.util.Arrays;  class GfG {          // Function to print median of stream of integers     static ArrayList<Double> getMedian(int[] arr) {         ArrayList<Double> res = new ArrayList<>();         res.add((double) arr[0]);          for (int i = 1; i < arr.length; i++) {             int j = i - 1;             int num = arr[i];              // shift elements to right to create space to insert             // the current element at its correct position             while (j >= 0 && arr[j] > num) {                 arr[j + 1] = arr[j];                 j--;             }             arr[j + 1] = num;              int len = i + 1;             double median;              // If odd number of integers are read from stream             // then middle element in sorted order is median             // else average of middle elements is median             if (len % 2 != 0) {                 median = arr[len / 2];             } else {                 median = (arr[(len / 2) - 1] + arr[len / 2]) / 2.0;             }              res.add(median);         }          return res;     }      public static void main(String[] args) {         int[] arr = {5, 15, 1, 3, 2, 8};         ArrayList<Double> res = getMedian(arr);                  for (int i = 0; i < res.size(); i++) {             System.out.printf("%.2f ", res.get(i));         }     } }

Python

# Python program to find Median from Running Data Stream # Using Insertion Sort  def getMedian(arr):     res = []          res.append(float(arr[0]))      for i in range(1, len(arr)):         j = i - 1         num = arr[i]          # shift elements to right to create space to insert         # the current element at its correct position         while j >= 0 and arr[j] > num:             arr[j + 1] = arr[j]             j -= 1         arr[j + 1] = num          length = i + 1          # If odd number of integers are read from stream         # then middle element in sorted order is median         # else average of middle elements is median         if length % 2 != 0:             median = arr[length // 2]         else:             median = (arr[(length // 2) - 1] + arr[length // 2]) / 2.0          res.append(median)      return res  if __name__ == '__main__':     arr = [5, 15, 1, 3, 2, 8]     res = getMedian(arr)          print(" ".join(f"{median:.2f}" for median in res))

// C# program to find Median from Running Data Stream // Using Insertion Sort using System; using System.Collections.Generic;  class GfG {          // Function to print median of stream of integers     static List<double> getMedian(int[] arr) {         List<double> res = new List<double>();         res.Add(arr[0]);          for (int i = 1; i < arr.Length; i++) {             int j = i - 1;             int num = arr[i];              // shift elements to right to create space to insert             // the current element at its correct position             while (j >= 0 && arr[j] > num) {                 arr[j + 1] = arr[j];                 j--;             }             arr[j + 1] = num;              int len = i + 1;             double median;              // If odd number of integers are read from stream             // then middle element in sorted order is median             // else average of middle elements is median             if (len % 2 != 0) {                 median = arr[len / 2];             }             else {                 median = (arr[(len / 2) - 1] + arr[len / 2]) / 2.0;             }              res.Add(median);         }          return res;     }      static void Main() {         int[] arr = { 5, 15, 1, 3, 2, 8 };         List<double> res = getMedian(arr);                  for (int i = 0; i < res.Count; i++)             Console.Write(res[i].ToString("0.00") + " ");              } }

JavaScript

// JavaScript program to find Median from Running Data Stream // Using Insertion Sort  function getMedian(arr) {     let res = [];      res.push(arr[0]);      for (let i = 1; i < arr.length; i++) {         let j = i - 1;         let num = arr[i];          // shift elements to right to create space to insert         // the current element at its correct position         while (j >= 0 && arr[j] > num) {             arr[j + 1] = arr[j];             j--;         }         arr[j + 1] = num;          let len = i + 1;         let median;          // If odd number of integers are read from stream         // then middle element in sorted order is median         // else average of middle elements is median         if (len % 2 !== 0) {             median = arr[Math.floor(len / 2)];         } else {             median = (arr[len / 2 - 1] + arr[len / 2]) / 2.0;         }          res.push(median);     }      return res; }  // Driver Code let arr = [5, 15, 1, 3, 2, 8]; let res = getMedian(arr);  console.log(res.map(median => median.toFixed(2)).join(" "));

Output

5.00 10.00 5.00 4.00 3.00 4.00

Time Complexity: O(n²), since insertion sort takes O(n²) time to sort n elements. Perhaps we can use binary search on insertion sort to find the location of the next element in O(log n) time. Yet, we can’t do data movement in O(log n) time. No matter how efficient the implementation is, it takes polynomial time in case of insertion sort.
Auxiliary Space: O(1)

[Expected Approach] Using Heaps

The median of an array occurs at the center of sorted array, so the idea is to store the current elements in two nearly equal parts. A max heap (left half) stores the smaller elements, ensuring the largest among them is at the top, while a min heap (right half) stores the larger elements, keeping the smallest at the top.

For each new element:

It is first added to the max heap.
The max heap’s top element is moved to the min heap to maintain order.
If the min heap has more elements than the max heap, its top element is moved back to ensure balance.
This keeps both halves nearly equal in size, differing by at most one element. If the heaps are balanced, the median is the average of their root values; otherwise, it is the root of the heap with more elements.

C++

// C++ program to find Median from Running Data Stream // Using Heaps #include <iostream> #include <vector> #include <queue> #include <iomanip> using namespace std;  // Function to find the median of a stream of data vector<double> getMedian(vector<int> &arr) {          // Max heap to store the smaller half of numbers     priority_queue<int> leftMaxHeap;          // Min heap to store the greater half of numbers     priority_queue<int, vector<int>, greater<int>> rightMinHeap;          vector<double> res;        for (int i = 0; i < arr.size(); i++) {         // Insert new element into max heap         leftMaxHeap.push(arr[i]);                  // Move the top of max heap to min heap to maintain order         int temp = leftMaxHeap.top();         leftMaxHeap.pop();         rightMinHeap.push(temp);                // Balance heaps if min heap has more elements         if (rightMinHeap.size() > leftMaxHeap.size()) {             temp = rightMinHeap.top();             rightMinHeap.pop();             leftMaxHeap.push(temp);         }                  // Compute median based on heap sizes         double median;         if (leftMaxHeap.size() != rightMinHeap.size())             median = leftMaxHeap.top();         else             median = (double)(leftMaxHeap.top() + rightMinHeap.top()) / 2;                  res.push_back(median);     }          return res; }   int main() {     vector<int> arr = {5, 15, 1, 3, 2, 8};     vector<double> res = getMedian(arr);     cout << fixed << setprecision(2);          for (double median: res)          cout << median << " ";     return 0; }

Java

// Java program to find Median from Running Data Stream // Using Heaps  import java.util.PriorityQueue; import java.util.ArrayList;  class GfG {          // Function to find the median of a stream of data     static ArrayList<Double> getMedian(int[] arr) {                  // Max heap to store the smaller half of numbers         PriorityQueue<Integer> leftMaxHeap = new PriorityQueue<>((a, b) -> b - a);                  // Min heap to store the greater half of numbers         PriorityQueue<Integer> rightMinHeap = new PriorityQueue<>();                  ArrayList<Double> res = new ArrayList<>();                for (int i = 0; i < arr.length; i++) {                          // Insert new element into max heap             leftMaxHeap.add(arr[i]);                          // Move the top of max heap to min heap to maintain order             int temp = leftMaxHeap.poll();             rightMinHeap.add(temp);                        // Balance heaps if min heap has more elements             if (rightMinHeap.size() > leftMaxHeap.size()) {                 temp = rightMinHeap.poll();                 leftMaxHeap.add(temp);             }                          // Compute median based on heap sizes             double median;             if (leftMaxHeap.size() != rightMinHeap.size())                 median = leftMaxHeap.peek();             else                 median = (leftMaxHeap.peek() + rightMinHeap.peek()) / 2.0;                          res.add(median);         }                  return res;     }      public static void main(String[] args) {         int[] arr = {5, 15, 1, 3, 2, 8};         ArrayList<Double> res = getMedian(arr);         System.out.printf("%.2f", res.get(0));                  for (int i = 1; i < res.size(); i++) {             System.out.printf(" %.2f", res.get(i));         }     } }

Python

# Python program to find Median from Running Data Stream # Using Heaps  import heapq  # Function to find the median of a stream of data def getMedian(arr):          # Max heap to store the smaller half of numbers     leftMaxHeap = []          # Min heap to store the greater half of numbers     rightMinHeap = []          res = []        for num in arr:         # Insert new element into max heap (negating for max behavior)         heapq.heappush(leftMaxHeap, -num)                  # Move the top of max heap to min heap to maintain order         temp = -heapq.heappop(leftMaxHeap)         heapq.heappush(rightMinHeap, temp)                # Balance heaps if min heap has more elements         if len(rightMinHeap) > len(leftMaxHeap):             temp = heapq.heappop(rightMinHeap)             heapq.heappush(leftMaxHeap, -temp)                  # Compute median based on heap sizes         if len(leftMaxHeap) != len(rightMinHeap):             median = -leftMaxHeap[0]         else:             median = (-leftMaxHeap[0] + rightMinHeap[0]) / 2.0                  res.append(median)          return res   if __name__ == "__main__":     arr = [5, 15, 1, 3, 2, 8]     res = getMedian(arr)          print(" ".join(f"{median:.2f}" for median in res))

// C# program to find Median from Running Data Stream // Using Heaps using System; using System.Collections.Generic; using System.Linq;  class GfG {     static void insert(SortedDictionary<int, int> heap, int num, ref int size) {         if (heap.ContainsKey(num))             heap[num]++;         else             heap[num] = 1;         size++;     }      static void remove(SortedDictionary<int, int> heap, int num, ref int size) {         if (heap[num] == 1)             heap.Remove(num);         else             heap[num]--;         size--;     }      static int getMax(SortedDictionary<int, int> heap) => heap.First().Key;     static int getMin(SortedDictionary<int, int> heap) => heap.First().Key;          static List<double> getMedian(int[] arr) {                  // Max heap for the smaller half (left side)         SortedDictionary<int, int> leftMaxHeap = new SortedDictionary             <int, int>(Comparer<int>.Create((a, b) => b.CompareTo(a)));         int leftSize = 0;          // Min heap for the greater half (right side)         SortedDictionary<int, int> rightMinHeap = new SortedDictionary                             <int, int>();         int rightSize = 0;          List<double> res = new List<double>();          foreach (int num in arr) {                          // Insert into max heap             insert(leftMaxHeap, num, ref leftSize);              // Move top from max heap to min heap             int temp = getMax(leftMaxHeap);             remove(leftMaxHeap, temp, ref leftSize);             insert(rightMinHeap, temp, ref rightSize);              // Balance the heaps             if (rightSize > leftSize) {                 temp = getMin(rightMinHeap);                 remove(rightMinHeap, temp, ref rightSize);                 insert(leftMaxHeap, temp, ref leftSize);             }              // Compute median             double median;             if (leftSize != rightSize)                 median = getMax(leftMaxHeap);             else                 median = (getMax(leftMaxHeap) + getMin(rightMinHeap)) / 2.0;              res.Add(median);         }          return res;     }      static void Main() {         int[] arr = {5, 15, 1, 3, 2, 8};         List<double> res = getMedian(arr);                  foreach (double median in res)             Console.Write(median.ToString("F2") + " ");     } }

JavaScript

//Driver Code Starts{ // JavaScript program to find Median from Running Data Stream // Using Heaps  class Heap {     constructor(compare) {         this.data = [];         this.compare = compare;     }      push(val) {         this.data.push(val);         this._heapifyUp();     }      pop() {         if (this.data.length === 0) return null;         if (this.data.length === 1) return this.data.pop();          const top = this.data[0];         this.data[0] = this.data.pop();         this._heapifyDown();         return top;     }      peek() {         return this.data[0] || null;     }      size() {         return this.data.length;     }      _heapifyUp() {         let index = this.data.length - 1;         while (index > 0) {             let parentIndex = Math.floor((index - 1) / 2);             if (this.compare(this.data[parentIndex], this.data[index])) break;                          [this.data[parentIndex], this.data[index]] = [this.data[index], this.data[parentIndex]];             index = parentIndex;         }     }      _heapifyDown() {         let index = 0;         const length = this.data.length;          while (true) {             let leftChildIdx = 2 * index + 1;             let rightChildIdx = 2 * index + 2;             let swapIdx = index;              if (leftChildIdx < length && !this.compare(this.data[swapIdx], this.data[leftChildIdx])) {                 swapIdx = leftChildIdx;             }             if (rightChildIdx < length && !this.compare(this.data[swapIdx], this.data[rightChildIdx])) {                 swapIdx = rightChildIdx;             }             if (swapIdx === index) break;              [this.data[index], this.data[swapIdx]] = [this.data[swapIdx], this.data[index]];             index = swapIdx;         }     } }  // MaxHeap (Stores smaller half of numbers) class MaxHeap extends Heap {     constructor() {         super((a, b) => a > b); // Max heap uses > comparator     } }  // MinHeap (Stores greater half of numbers) class MinHeap extends Heap {     constructor() {         super((a, b) => a < b); // Min heap uses < comparator     } } //Driver Code Ends }  // Function to find the median of a stream of data function getMedian(arr) {          // Max heap for left side     let leftMaxHeap = new MaxHeap();     // Min heap for right side     let rightMinHeap = new MinHeap();           let res = [];      for (let num of arr) {         // Insert into max heap         leftMaxHeap.push(num);          // Balance heaps by moving element to min heap         rightMinHeap.push(leftMaxHeap.pop());          // Ensure left heap has more or equal elements         if (rightMinHeap.size() > leftMaxHeap.size()) {             leftMaxHeap.push(rightMinHeap.pop());         }          // Compute median based on heap sizes         let median;         if (leftMaxHeap.size() !== rightMinHeap.size())             median = leftMaxHeap.peek();         else             median = (leftMaxHeap.peek() + rightMinHeap.peek()) / 2.0;                  res.push(median);     }      return res; }  // Driver Code let arr = [5, 15, 1, 3, 2, 8]; let res = getMedian(arr);  console.log(res.map(median => median.toFixed(2)).join(" "));

Output

5.00 10.00 5.00 4.00 3.00 4.00

Time Complexity: O(n * log n), All the operations within the loop (push, pop) take O(log n) time in the worst case for a heap of size n.
Auxiliary Space: O(n)

Largest triplet product in a stream

kartik

Improve

Article Tags :

Practice Tags :

Find Median from Running Data Stream

[Naive Approach] Using Insertion Sort

[Expected Approach] Using Heaps

Similar Reads

Some other type of Heap

Easy problems on Heap