Median of Stream of Running Integers using Python

Consider that you are reading numbers from a file or array, or just inputting in one and then a different one, and that an ongoing flow of numbers is flowing in. The number that falls between each of the figures you have seen up to this point must be determined. Locating the "median" when a growing quantity of data accumulates becomes what we refer to in this situation.

It's similar to requesting the machine to identify the middle number while you continue introducing fresh ones to the lists, as you address having this work with machines and machine learning. The challenging component is that, even though the values might originate from any source, such as a record or just by entering things in, the machine in question must still determine the median.

So, in simple terms, finding the "median of running integers" means finding the middle number in a series of numbers that keep coming in, and it's a bit of a puzzle when the numbers don't come in any specific order.

Place yourself in the position of obtaining a string of figures from a source, such as an application on a computer. Finding the "median" for every one of the numbers that you have seen thus far is what you are trying to do. Assuming there are no repeating numerals will make things straightforward.

Take a series of figures, like 5, 15, 1, 3, for example.

The mean is merely 5, as it's just one amount after viewing that initial one (5).

After reading the second number (15), you have two numbers (5 and 15), and the median is the number in the middle when you arrange them in order. So, in this case, the median is 10 (the average of 5 and 15).

When you read the third number (1), you have three numbers now (5, 15, and 1). To find the median, you sort them and pick the middle number, 5.

And as you analyze the final number (3), you're presented with the subsequent four numbers: 5, 15, 1, and 3. After classifying them, you obtain 1, 3, 5, and 15. The median is the average of the two middle numbers, 4.

This process continues as you read more numbers.

Based on whether you're dealing with an even or odd number of items, this approach to computing the mean as you go is known as an "online algorithm." It suggests that you can calculate the median value even if you are unaware of all the values in Grow, which makes it handy in various circumstances.

Let's immediately discuss several potential approaches to this issue.

What is the Median?

The median is a way to find a middle point in a group of numbers. It assists us in comprehending the distribution of facts. This is how we determine it:

Abnormal Quantity of Documents If our collection has a non-even number of values, we merely locate one that falls exactly in the center whenever the information is arranged from greatest to biggest. That middle number is our median.

If exactly two figures are in the center of an even number of standards, we can calculate the mean by averaging the two values.

In summary, the average provides us with a general concept of the "middle" position in a group of figures and aids in comprehending a collection of facts.

Example 1 :

The words "max heap" and "min heap" refer to several unique data structures that will be used to assist us in addressing this challenge. These function as compartmentalized receptacles for figures, with the maximum heap holding greater quantities and the lower heap holding fewer ones. Programmers may generate max and minimal heaps by utilizing a tool termed "priority_queue" in C++ or Python.

Let's next outline the method we'll use to solve this issue through each step.

Code:

from heapq import *
def Medians(arr, n):
    max= []
    min = []	
    heapify(max)
    heapify(min)
    median = arr[0]
    heappush(max, arr[0])
    print(median)
    for i in range(1, n):
        ele= arr[i]
        if len(max) > len(min):
            if ele < median:
                heappush(min, heappop(max))
                heappush(max, ele)
            else:
                heappush(min, ele)
                median = (nlargest(1, max)[0] + nsmallest(1, min)[0])/2
        elif len(max) == len(min):
            if ele < median:
                heappush(max, ele)
                median = nlargest(1, max)[0]
            else:
                heappush(min, ele)
                median = nsmallest(1, min)[0]
        else:
            if ele > median:
                heappush(max, heappop(min))
                heappush(min, ele)
            else:
                heappush(max, ele)
            median = (nlargest(1, max)[0] + nsmallest(1, min)[0])/2
        print(median)
arr = [5, 15, 10, 20, 3]
Medians(arr, len(arr))

Output:

This code is for a Python function called "Medians." The current medians of a set of values are subsequently computed and shown by them. It operates as follows:

It starts by importing some tools needed to work with heaps. Think of heaps as organized lists of numbers.
Then, it defines the "Medians" function, which takes two things as input:
A list of numbers you want to find medians for.
The total number of elements in that list.
It sets up two empty lists called "max" and "min." These lists will be used to keep track of the largest and smallest numbers as we go through the input list.
It turns these empty lists into proper heaps using the "heapify" function. In essence, it ensures that the list of items is properly arranged.
The first value it chooses from the information you provide is then referred to as the "median" for its duration. It also puts this number into the "max" heap.
It shows you this initial median.
Then, it starts going through the rest of the numbers in your input list one by one.
For each number it goes through:
It counts the total quantity of values in the "max" heap and the "min" heap.
If there are additionally additional numbers inside the "max" heap, it determines whether that particular value belongs in the "max" band or the "min" band and makes the necessary adjustments.
It adds the present total to one of both wastes and changes the median value if both contain the same number of digits.
It behaves similarly to when it saw a greater number in the "max" heap when there were additional values in the "min" waste.
It displays the new average after placing the currently displayed value in the appropriate context and making the necessary adjustments.
This process continues until it has looked at all the numbers in your input list.

In simple terms, this code helps find the running medians of a list of numbers. In addition to updating and displaying the average as it analyzes each value, it maintains records of the largest and smallest digits as it works throughout the list. It's an effective method of doing things.

Example 2 : Insertion sort

Have you ever considered how we can determine the central number in an array of figures? One way is by using something called "Insertion Sort." Whenever you get cards, it's like going through a collection of decks.

Assume you are handed a list of numerals, one at a time. Insertion Sort allows you to categorize the digits instantly as they are received. So, after the first digit has been categorized, it is in the proper location. Then, after you get the third amount, place it between the previous ones properly.

This process continues as you get more numbers. The key is that Insertion Sort can only know some of the future numbers to sort the ones you have. It looks at the sorted numbers and adds the new ones in the right order. This is what makes Insertion Sort an "online algorithm."

In simple terms, it's like organizing your cards as you receive them without needing to see all the cards in advance. That's how Insertion Sort works to find the median element efficiently.

Code:

def binarySearch(array, ele, l, h):
   if (l >= h):
        return (l + 1) if (ele > array[l]) else l
        mid = (l + h) // 2
        if (ele == array[mid]):
		return mid + 1
        if (ele > array[mid]):
		return binarySearch(array, ele, mid + 1, h)

       return binarySearch(array, ele, l, mid - 1)
# Function to print median of stream of integers
def median(array, n):
           i, j, posi, nums= 0, 0, 0, 0
	c = 1
          print(f"Median after taking 1 element is {array[0]}.0")
          for i in range(1, n):
		median = 0
		j = i - 1
		nums = array[i]
		posi = binarySearch(array, nums, 0, j)
		while (j >= posi):
			array[j + 1] = array[j]
			j -= 1
                      array[j + 1] = nums
                     c += 1
                     if (c % 2 != 0):
			median = array[c // 2] / 1
                     else:
			median = (array[(c // 2) - 1] + array[c // 2]) / 2

		print(f"Median after taking {i + 1} elements is {median} ")
if _name_ == "_main_":
           array = [2,4,6,8,9]
           n = len(array)
          median(array, n)

Output:

Median after taking 1 element is 2.0
Median after taking 2 elements is 3.0 
Median after taking 3 elements is 4.0 
Median after taking 4 elements is 5.0 
Median after taking 5 elements is 6.0

The code you shared is like a recipe written in a computer language called Python. Given a list of figures, it is intended to do some mathematical operations and get what is known as a "running median," or a sort of middle number in a list.

But there are a few issues concerning the recipe. Think of a recipe where certain components have been removed or written incorrectly, the instructions won't be in the proper sequence, and ultimately there are mistakes. I'll provide the proper method step-by-step in a particular manner:

Step 1: Finding the Right Spot

We start with a function called "binary search." This function aids us in locating the proper location for certain numbers in our list of numbers to guarantee the list maintains its order. It's similar to locating the ideal library shelf at an institution of learning for a brand-new publication.

Step 2: Calculating the Running Median

Now, let's talk about the main part of our recipe, the "median" function. This part is responsible for finding the running median of a bunch of numbers in our list.

We have some special cups (variables) called i, j, posi, nums, and c.

i is like a pointer that helps us keep track of where we are in the list.

j is another helper pointer.

posi tells us where we want to put our new number.

nums keeps track of how many numbers we have.

c is our counting cup; it counts how many numbers are in our list.

We start by printing the median of just one number (the first one).

The listing is then traversed, starting at the number two spot and ending at number one.

We determine the proper placement of each integer in our sorted list using the "binary search" method. On a shelf, it's similar to choosing the ideal place for a new novel.

We change our measuring cup (c) to reflect that we now have one more amount in the list before placing the number in the proper location.

We next calculate the average, which is equivalent to locating the middle number in our list as our subsequent step. If there are a number of evens or an odd number of numerals, we handle this accordingly.

Finally, our recipe runs when a special condition is met (if name == "main"). In the above example, we're applying the formula to get the continuous median for the range of integers [2, 4, 6, 8, 9].

Keep in mind that the initial dish included a few errors, including sloppy handwriting, mismatched components, and even the wrong sequence of the stages.I've fixed those issues in the explanation above. Make sure to follow this corrected recipe for it to work correctly.

Example 3 :

When working with a binary search tree (BST), like AVL or Red-Black trees, we often want to find the median, which is the middle value in a set of numbers. But how can we do this efficiently?

One clever approach is to augment the BST with additional information at each node. The node itself retains a record of how many items are present in the subtree that has its origin at that node's location, rather than merely keeping a value. Consider this as making each of the nodes the main node of a little binary tree. The second child has pieces that are greater than the origin, whereas the left daughter has components that are lower than the root element.This way, the root always holds the effective median.

Now, here's where it gets interesting. If the left and right subtrees have the same number of elements, the root node contains the average of the data in those subtrees. But if one subtree has more elements than the other, the root simply takes on the data of the larger subtree's root.This keeps our tree balanced, with the left and right subtrees differing by at most one element.

Traditional self-balancing BSTs can be expensive to manage because they maintain a strict balance at all times, which isn't necessary for finding the median. We're not interested in keeping the data perfectly sorted; we just want to find the median quickly. This augmented approach, on the other hand, uses clever tree structures to efficiently trace the median without the unnecessary overhead of maintaining a perfectly balanced tree.

Code:

from heapq import heappush, heappop, heapify
import math
def Median(array, N):
	max = []
	min = []
	for i in range(len(array)):
		heappush(min, -array[i])
		heappush(max, -heappop(min))
		if len(max) > len(min):
			heappush(min, -heappop(max))

		if len(max) != len(min):
			print(-min[0])
		else:
			print((max[0] - min[0])/2)
if __name__ == '__main__':
	Array = [2,4,6,8,9]
	N = len(Array)
	Median(Array, N)

Output:

This program accomplishes something quite intriguing. Locating the middle number among a group of digits is similar to making an illusion. Let me explain it to you in plain terms:

In the beginning, the srcipt imports several unique language utilities, Sort of like a useful tool.These tools help with sorting and doing math stuff.

But there is a function named "Median" that accepts two parameters: a collection of digits and the total number of values.

There are two unique stacks inside the task, one titled "min" and one that is titled "max."These piles help keep track of the smaller and bigger numbers. But don't get confused with Python's "min" and "max" functions; these are different.

Now, imagine you have a list of numbers. The code goes through each number one by one:

It does a little trick by flipping the number's sign (positive to negative) and puts it on the "min" pile. This is because Python's tools work better with "min" piles.
The minimal amount is then transferred from the "min" pile to the "max" pile. As a result, both the tiny and larger halves of the numbers remain in separate piles.
A certain number is transferred across the "max" mound to the "min" pile to maintain balancing if the "max" pile grows larger than that of the "min" pile.This ensures that the piles are almost the same size.
Finally, it checks if the piles are the same size. If so, it collects the highest values from each pile and divides the result by two to figure out the middle amount (which is the median). It just provides you with the greatest integer that comes from the "min" pile and is also the median if they are not all exactly the same size.

It offers you the average value after going over all the statistics. In order to quickly get the mean of a list of integers, the above program ultimately makes use of some cunning heap tactics.It's like magic!

Example 4 :

Code:

import heapq
class RunningMedian:
    def __init__(self):
        self.min_heap = []  
        self.max_heap = []  
    def insert(self, num):
        if not self.max_heap or num <= -self.max_heap[0]:
            heapq.heappush(self.max_heap, -num)
        else:
            heapq.heappush(self.min_heap, num)
       if len(self.max_heap) > len(self.min_heap) + 1:
            num = -heapq.heappop(self.max_heap)
            heapq.heappush(self.min_heap, num)
        elif len(self.min_heap) > len(self.max_heap):
            num = heapq.heappop(self.min_heap)
            heapq.heappush(self.max_heap, -num)
     def get_median(self):
        if len(self.max_heap) == len(self.min_heap):
            median = (-self.max_heap[0] + self.min_heap[0]) / 2
        else:
            median = -self.max_heap[0]  
        return median
stream = [2,4,6,8,9]
running_median = RunningMedian()
for num in stream:
    running_median.insert(num)
    print(running_median.get_median())

Output:

This Python code defines a class called RunningMedian that calculates the running median of a stream of numbers using two heaps: a max heap and a min heap. The program shows how to utilize this class to determine the currently running median for any trickle of integers.

The syntax of the code is explained as follows:

adding the heapq package Heap queue techniques are offered by the Python package heapq.In this code, it's used to implement the max heap and min heap.

Define the RunningMedian class.

The min_heap and max_heap pools are initialized using the __init__ method. By canceling the integers while creating it, the max_heap, which is a max heap, is carried out as a min pile.

Adding another integer to the information structure is done using the insert technique. The subsequent actions are:

Place the negate integer into max_heap if either max_heap is vacant or the value is less than or equal to the negating amount, which is the maximum element in max_heap.

In the absence of it, enter the value for min_heap.

The procedure then determines if the max_heap size is more than one larger than the min_heap size after every single one has been inserted. If so, it negates the highest component, pops it from the max_heap, and then pushes it towards the min_heap in order to rebalance the heap. According to the last example, if min_heap is bigger than max_heap, the minimal piece is removed from min_heap, negated, and pushed onto max_heap.

Using the heaps' most recent configuration as a basis, the get_median operation calculates and returns the currently active median:

The standard deviation is the ratio of the largest element in max_heap (after negation) to the least component in min_heap if the values of max_heap and min_heap are identically equivalent.

The average is just the top-most element in max_heap (after negation) if its dimensions aren't equal.

Make a list stream that contains the following input: [2, 4, 6, 8, 9].

Make new instances of the RunningMedian class named running_median.

Work backwards through the succession of numbers, iterating across each one as you go.

Insert the number into the running_median object using the insert method.

Print the current running median by calling the get_median method.

The code essentially maintains a balanced set of numbers using the max heap (max_heap) and min heap (min_heap) to efficiently calculate the running median as numbers are inserted one by one. The running median is printed after each Insertion in the stream.

Next TopicPosixpath-module-in-python

← prev next →