Python Solution of Median of Two Sorted Arrays

In this problem, we will be given two arrays. Let the arrays be array1 and array2. These two arrays will be sorted and can have different sizes. Let the size of the two arrays be n and m where n is the number of elements in array1 and let m be the number of elements in array2.

Let us see some examples to understand the problem.

Input: array1 = [-5, 2, 7, 9, 11], array2 = [-13, -10, -6, 3, 6, 13]

Output: The median of the two arrays is 3.

If we will merge both the arrays the new array will be sorted = [-13, -10, -6, -5, 2, 3, 6, 7, 9, 11, 13]

Since the number of elements is 11, i.e., an odd number of elements, median = (n + m - 1) / 2, the 6th element. Sorted[6] = 3

Input: array1 = [3, 6, 9, 10], array2 = [4, 7, 10, 11, 12, 13]

Output: The median of two sorted arrays is 9.50

If we merge both the arrays, the new array will be sorted = [3, 4, 6, 7, 9, 10, 10, 11, 12, 13]

Since the number of elements is 10, i.e., even number of elements, median = [(n + m) / 2, ((n + m ) / 2) + 1], we will take the average of these two values. Therefore median will be (sorted[5] + sorted[6]) / 2 = 9.50.

Approach - 1

The most basic approach to solve this problem is to create a third array. This third array will store the sum of two arrays; hence, the total size of this array will be n + m. We will sort this new array and find the median element. We must check if n + m is odd or even to find the median. As shown above, if the total length of the third array is odd, then the median is present at (n + m - 1) / 2 index of the sorted array. However, if the length of the third array is even, the median is the average of the two elements present at the indices (n + m) / 2 and ((n + m ) / 2) - 1 of the sorted array.

The idea is very similar to the example shown above. We will follow these steps to solve the problem.

Create a new array, array3. array3 will contain all the elements present in array1 and array2. We can do this by using the arithmetic operator on the two lists. Python lists are not added elementwise.
Then, we will sort the array3 using the built-in sorted() function.
The next step is to check if the length of array3 is even or odd
If the length of array3 is odd, then find median as array3[(n + m - 1) // 2]. If the length of the array3 is even then we will find the average of array3[n + m) // 2] and array3[((n + m ) // 2) - 1].

Now we will see the Python code for the above approach:

Code

# Python program to find the median of two sorted arrays.

# Defining a function that will take two arrays and return the median element
def median(array1, array2):

  n = len(array1)
  m = len(array2)

  # Creating the third array that will contain all the elements of array1 and array2
  array3 = array1 + array2

  # Now, we will sort the third array using the sorted() function
  array3 = sorted(array3)
  print("The sorted array is: \n", array3)

  # Checking if the length of array3 is even or odd
  if (n + m) % 2 != 0:
   # If the length is odd
   median = array3[(n + m - 1) // 2]

  else:
   # If the length is even
   median = (array3[(n + m) // 2] + array3[((n + m) // 2) - 1]) / 2
 
  # Returning the median value
  return median

# Creating two sorted arrays and passing them to the function
array1 = [-5, 2, 7, 9, 11]
array2 = [-13, -10, -6, 3, 6, 13]

print("The median of the sorted array is:", median(array1, array2))

array1 = [3, 6, 9, 10]
array2 = [4, 7, 10, 11, 12, 13]
print("The median of the sorted array is:", median(array1, array2))

Output:

The sorted array is:
 [-13, -10, -6, -5, 2, 3, 6, 7, 9, 11, 13]
The median of the sorted array is: 3
The sorted array is:
 [3, 4, 6, 7, 9, 10, 10, 11, 12, 13]
The median of the sorted array is: 9.5

Time Complexity: We have to sort the third array of size (n + m). The time complexity will be O(Log (n + m)) to sort this array.

Auxiliary Space: We are using extra memory space to store the third array, making the space complex O(n + m).

Approach - 2

We will use an efficient approach to sort the two arrays, decreasing the time complexity.

The two arrays that are given to us here are sorted. We can use this property and merge the two arrays more efficiently instead of adding and sorting them later. We will maintain the count of the arrays that we have put in order, and when we reach half the total number of elements in both arrays, we will print the median element. In this approach, too, we have to deal with the two cases that appear based on the sum of the lengths of the two arrays.

If the sum of lengths is odd, then the median is the value present in the (m + n) / 2 index after merging the two arrays.

If the sum of lengths is even, then the median is the average of the values in the (m + n) / 2 and (m + n) / 2 + 1 indices after merging the two arrays.

Let us have a dry run to understand this approach.

Let us take an example of two sorted arrays array1 = [3, 7] and array2 = [1, 2, 4, 5, 6].
Here n = length of array1 = 2 and m = length of array2 = 5
The sum of the lengths = 7, which means the median is the 4th value.
We will run a loop from 0 to 3.
In the first iteration, we will compare the 0th element of the two arrays. Since 1 < 4, median = 1
In the second iteration, we will compare the 0th element of array1 and the first element of array2. Since, 2 < 4, m1 = 2
In the third iteration, we will compare the 0th element of array1 and the second element of array2. Since, 3 < 4, m1 = 3
In the final iteration, we will compare the second element of array1 and the second element of array2. Since, 4 < 7, m1 = 4.
The final value of m1 is the median of the two arrays, which is 4.
We don't need to go further because the array's length is odd.

Below is the Python code for this approach.

Code

# Python program to find the median of two sorted arrays in a linear time complexity.

# Defining a function that will take two sorted arrays and return the median of those arrays.
def median(array1, array2, n, m):

  # Initializing the pointers
  # This will keep track of elements of array1
  p1 = 0
  # This will keep track of elements of array2
  p2 = 0 

  # Initializing variables that will store the median values
  m1, m2 = -1, -1

  # Running a for loop, which will run till half of the length of the total length of two arrays
  for _ in range(((n + m) // 2) + 1):
    if(p1 != n and p2 != m):
      if array1[p1] > array2[p2]:
        m1 = array2[p2]
        p2 += 1
      else:
        m1 = array1[p1]
        p1 += 1
    elif(p1 < n):
      m1 = array1[p1]
      p1 += 1
    else:
      m1 = array2[p2]
      p2 += 1
      # We will return m1 if the total length is odd; otherwise we will return (m1 + m2) // 2
  return m1 if (n + m) % 2 != 0 else (m1 + m2) // 2


# Creating two sorted arrays and passing them to the function
array1 = [-5, 2, 7, 9, 11]
array2 = [-13, -10, -6, 3, 6, 13]
n1 = len(array1)
n2 = len(array2)
print("The median of the sorted array is:", median(array1, array2, n1, n2))

array1 = [3, 6, 9, 10]
array2 = [4, 7, 10, 11, 12, 13]
n1 = len(array1)
n2 = len(array2)
print("The median of the sorted array is:", median(array1, array2, n1, n2))

Output:

The median of the sorted array is: 3
The median of the sorted array is: 9.5

Time Complexity: We need to sort the merged array in this approach. We have found the median using a single for loop. Therefore, the time complexity of this approach is O(m + n).

Auxiliary Space: Unlike the previous approach, we have not stored anything where we stored merged arrays. Therefore, the space complexity of this approach is constant, i.e., O(1).

Approach - 3

We will use binary search in this approach.

As we saw in the previous approach, the property that the given two arrays are sorted can be utilized to design an efficient approach to find the median of two arrays. One of the most commonly used approaches for sorted arrays is binary search. We will use binary search to divide the two arrays without explicitly merging and sorting them.

We must find a point that can divide the merged array into two equal parts to find the median. We can use binary search to find a point in both the arrays individually. When we merge the two arrays, those points will merge too and will be the point that divides the merged array into two equal parts.

Let us take an example: array1 = [-5, 2, 7, 9, 11], array2 = [-13, -10, -6, 3, 6, 13]

We have to find two cuts on these arrays. Let the cut1 be between 2 and 7 in the first array and cut2 be between 3 and 6 in the second array. When we merge the two halves individually, they will be half1 = [-13, -10, -6, -5, 2, 3] and half2 = [6, 7, 9, 11, 13].
As we can see, 3 is the median of this array, and the two cuts, when merged, form two halves of the merged array. Hence, we have to find the index of cut1 and cut2 for the two sorted arrays through binary search.

Now, we will see the steps we must follow to solve this problem using Python.

We will apply binary search on the array that has a bigger length.
To find the median, we should know where the median lies. As we have seen in previous examples, when merged to one, the median of the sorted arrays lies at (m + n + 1) / 2 of the merged array. We will call this median_position.
We will find the mid-point of the array that has a bigger length. Let this be array1, and the length be n. The other array will be array2, and its length will be m. The midpoint of array1 will be the cut of the first array. Let the mid-point be called as cut1. Now the number of elements on the left side of cut1 is equal to the value of cut1. Obviously, on the left side of the merged array, the remaining number of elements will be median_position - cut1. These elements will be present in the second array. Therefore, the cut of the second array, i.e., cut2 = median_position - cut1.
After the two cuts, there are four parts of the two arrays.
- L1 = left part of cut1
- L2 = left part of cut2
- R1 = right part of cut1
- R2 = right part of cut2
But to reach the final answer, we need to confirm if the partitions made are correct or not. To validate a partition, we need to check if the value of L1 <= R2 and L2 <= R1. If this condition follows, we will check if the total length (m + n) is odd or even. If the total length is even, we will return the average of max(L1, L2) and min(R1, R2). We will return max(L1, L2) if the total length is odd.
However, if the condition does not hold true, we will use the binary search conditions. If the value of L1 is greater than the value of R2, then we will shift mid to cut1 - 1.

Code

# Python program to find the median of two sorted arrays using the binary search method

# Defining a function that will take two arrays as its parameter and find the median using binary search
def median(array1, array2):

  # Finding the length of the two given arrays
  n = len(array1)
  m = len(array2)

  # We have to apply binary search on the array that has a bigger length
  # Assuming the array of length n is the bigger one if m > n, then we will swap the arrays and the lengths
  if (m > n):
    array1, array2 = array2, array1
    n, m = m, n

  # Initiaizing the pointers of the binary search
  l = 0
  h = n

  # Finding the actual position of the median in the merged sorted array
  median_position = (n + m + 1) // 2

  # Starting the while loop
  while (l <= h):
    mid = (l + h) // 2

    # Defining the cuts on the two arrays
    cut1 = mid
    cut2 = median_position - mid

    # Finding the elements that are on the left and right sides of the two arrays
    # We need to find these to validate the cuts and also to find th final answer
    # Here we will check the edge cases two, like if cut1 = 0, then cut1 - 1 will not be the left side of cut1
    l1 = array1[cut1 - 1] if cut1 != 0 else float('-inf')
    l2 = array2[cut2 - 1] if cut2 != 0 else float('-inf')
    r1 = array1[cut1] if cut1 != n else float('inf')
    r2 = array2[cut2] if cut2 != m else float('inf')

    # Checking if the current cuts are correct or not
    if l1 <= r2 and l2 <= r1:
      # If the cuts are proper, then we will find the median
      # If the total length of the two arrays is even, then we need to find the median of the two values that will be beside the cut of the merged array
      # These two values will be the maximum of the left sides and a minimum of the right sides
      if ((m + n) % 2 == 0):
        return (max(l1, l2) + min(r1, r2)) / 2.0

      # If the sum of lengths is odd, then the median is just the middle value, which will be the maximum of the left-side values
      return max(l1, l2)

    # If the cuts are not proper, then we need to shift the cuts
    # If the value of l1 > r2 that means we need to decrease l1 and increase r2.
    # this can be done by shifting cut1 to the left and shifting cut2 to the right
    # Since the binary search is applied on a single array, we will shift cut1, and cut2 will be shifted using median_position - cut1
    elif (l1 > l2):
      h = cut1 - 1
    else:
      # If the l2 > r1, then we have to do the opposite of what we did in the previous case.
      # We have to shift cut1 to the right and shift cut2 to the left
      l = cut1 + 1

# Creating the arrays and finding the median
array1 = [-5, 2, 7, 9, 11]
array2 = [-13, -10, -6, 3, 6, 13]
print("The median of the sorted array is:", median(array1, array2))

array1 = [3, 6, 9, 10]
array2 = [4, 7, 10, 11, 12, 13]
print("The median of the sorted array is:", median(array1, array2))

Output:

The median of the sorted array is: 3
The median of the sorted array is: 9.5

Time Complexity: We are applying binary search on the array with greater length. Therefore, the time complexity will be O(max(log m, log n)). We applied this condition to pass the cases where the length of one of them is 0.

Auxiliary Space: We have not used extra space to store the array. Therefore, the space complexity is constant, hence, O(1).

Approach - 4

In this approach, we will use Priority Queue min Heap to find the median value.

We will find the median value using the priority queue by iterating over the arrays until we reach the median index.

Let us understand the algorithm with the help of an illustration.

array1 = [-5, 2, 7, 9, 11], array2 = [-13, -10, -6, 3, 6, 13], n = 5, m = 6

(n = length of array1, m = length of array2)

Step 1: We will initialize a priority queue p_q. We will add the elements of the first array to the priority queue.

p_q.push(-5)

p_q.push(2)

p_q.push(7)

p_q.push(9)

p_q.push(11)

When we add all the first array elements to the priority queue, the final queue will be [-5, 2, 7, 9, 11].

Step 2: Now we will add the elements of the second array to the priority queue.

p_q.push(-13)

p_q.push(-10)

p_q.push(-6)

p_q.push(3)

p_q.push(6)

p_q.push(13)

When we add the elements of the second array to the priority queue, the final queue will be p_q = [-13, -10, -6, -5, 2, 3, 6, 7, 9, 11, 13]

Step 3: The final step is to find the median value. We will find the median using approaches based on the condition that the priority queue length is even or odd.

If the length of the priority queue is odd

Then, we will iterate over the queue for (n + m) // 2 number of times. In each iteration, we will pop an element from the queue.

At the end of the iteration, the top element of the queue will be the median.

If the length of the priority queue is even

Then we will iterate over the priority queue upto (n + m) // 2 and ((n + m) // 2) - 1. We will return the average of the top elements of the queue.

Here is the Python code for this approach.

Code

# Python code to find the median of two sorted arrays using the Priority Queue

# Importing the library to use a queue data structure
import heapq

# Defining a function that takes two arrays and returns the median value
def median(array1, array2):

  # Calculating the lengths of the two arrays
  n, m = len(array1), len(array2)

  # initializing an empty Priority Queue
  p_q = []

  # First, we will add the elements of array1 to the priority queue
  for _ in range(n):
    heapq.heappush(p_q, array1[_])

  # Next, we will push the elements of array2 in the priority queue
  for _ in range(m):
    heapq.heappush(p_q, array2[_])

  # Total length of the priority queue
  total = n + m
  idx = -1
  m1, m2 = -1, -1

  # Using a while loop to traverse over the priority queue
  while p_q:

    # Maintaining the index value
    idx += 1

    # If the total length of the priority queue is odd, then we will return the middle element
    if total % 2 != 0 and idx == total // 2:
      return p_q[0]
    # We need to keep track of the two middle elements in case the total length of the priority queue is even
    # Then we will return the average of these mid-values
    if total % 2 == 0 and idx == (total // 2) - 1:
      m1 = p_q[0]
    
    # If the total length is even, then return the average of the middle elements
    if total % 2 == 0 and idx == total // 2:
      m2 = heapq.heappop(p_q)
      return (m1 + m2) / 2
    heapq.heappop(p_q)
  
  # This condition will be executed if the arrays are empty
  return 0.00000


# Creating the arrays and finding the median
array1 = [-5, 2, 7, 9, 11]
array2 = [-13, -10, -6, 3, 6, 13]
print("The median of the sorted array is:", median(array1, array2))

array1 = [3, 6, 9, 10]
array2 = [4, 7, 10, 11, 12, 13]
print("The median of the sorted array is:", median(array1, array2))

Output:

The median of the sorted array is: 3
The median of the sorted array is: 9.5

Time Complexity: Here, the time complexity will be O(max(n, m) * log(max(n, m))). The time complexity is this because we used a priority queue for both arrays.

Auxiliary Space: We have used extra space to store the priority queue. Hence, the space complexity will equal the length of the priority queue, i.e., O(n + m).

Next TopicThe Maximum Sum Subarray Problem

← prev next →