Median of two Sorted Arrays of Different Sizes

// C Code to find Median of two Sorted Arrays of 
// Different Sizes using Sorting

#include <stdio.h>

// Function to compare two integers for qsort
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

double medianOf2(int a[], int n, int b[], int m) {
    
  	// Calculate the total size of the concatenated array
    int len = n + m;
    
    int c[len];
    
    // Concatenate a and b into c
    for (int i = 0; i < n; ++i)
        c[i] = a[i];

    for (int i = 0; i < m; ++i)
        c[n + i] = b[i];
    
    // Sort the concatenated array
    qsort(c, len, sizeof(int), compare);
    
    // Calculate and return the median
    int mid = len / 2;
    
  	// If length of array is even
    if (len % 2 == 0) 
        return (c[mid] + c[mid - 1]) / 2.0;
  
  	// If length of array is odd
  	else 
        return c[mid];
}

int main() {
    int a[] = { -5, 3, 6, 12, 15 };
    int b[] = { -12, -10, -6, -3, 4, 10 };
    
    int n = sizeof(a) / sizeof(a[0]);
    int m = sizeof(b) / sizeof(b[0]);
    
    printf("%f\n", medianOf2(a, n, b, m));
    
    return 0;
}

// C Code to find the median of two sorted arrays
// using Merge of Merge Sort

#include <stdio.h>

double medianOf2(int a[], int n, int b[], int m) {
    int i = 0, j = 0;
  
    // m1 to store the middle element
    // m2 to store the second middle element
    int m1 = -1, m2 = -1;

    // Loop till (m+n)/2
    for (int count = 0; count <= (m + n) / 2; count++) {
        m2 = m1;
      
        // If both the arrays have remaining elements
        if (i != n && j != m)
            m1 = (a[i] > b[j]) ? b[j++] : a[i++];
        
        // If only a[] has remaining elements
        else if (i < n) 
            m1 = a[i++];
      
        // If only b[] has remaining elements
        else 
            m1 = b[j++];
    }

    // Return median based on odd/even size
    if ((m + n) % 2 == 1) 
        return m1;
    else
        return (m1 + m2) / 2.0;
}

int main() {
    int arr1[] = { -5, 3, 6, 12, 15 };
    int arr2[] = { -12, -10, -6, -3, 4, 10 };
    
    int n = sizeof(arr1) / sizeof(arr1[0]);
    int m = sizeof(arr2) / sizeof(arr2[0]);

    printf("%f\n", medianOf2(arr1, n, arr2, m));
    return 0;
}

// C Program to find the median of two sorted arrays
// of different size using Binary Search

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

double medianOf2(int a[], int n, int b[], int m) {

    // If a[] has more elements, then call medianOf2
    // with reversed parameters
    if (n > m)
        return medianOf2(b, m, a, n);

    int lo = 0, hi = n;
    while (lo <= hi) {
        int mid1 = (lo + hi) / 2;
        int mid2 = (n + m + 1) / 2 - mid1;

        // Find elements to the left and right of partition in a[]
        int l1 = (mid1 == 0) ? INT_MIN : a[mid1 - 1];
        int r1 = (mid1 == n) ? INT_MAX : a[mid1];

        // Find elements to the left and right of partition in b[]
        int l2 = (mid2 == 0) ? INT_MIN : b[mid2 - 1];
        int r2 = (mid2 == m) ? INT_MAX : b[mid2];

        // If it is a valid partition
        if (l1 <= r2 && l2 <= r1) {
            
            // If the total elements are even, then median is 
            // the average of two middle elements
            if ((n + m) % 2 == 0)
                return (max(l1, l2) + min(r1, r2)) / 2.0;

            // If the total elements are odd, then median is 
            // the middle element
            else
                return max(l1, l2);
        }

        // Check if we need to take fewer elements from a[]
        if (l1 > r2)
            hi = mid1 - 1;

        // Check if we need to take more elements from a[]
        else
            lo = mid1 + 1;
    }

    return 0;
}

// Helper functions for max and min
int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int main() {
    int a[] = {1, 12, 15, 26, 38};
    int b[] = {2, 13, 17, 30, 45, 60};
    
    int n = sizeof(a) / sizeof(a[0]);
    int m = sizeof(b) / sizeof(b[0]);

    printf("%f\n", medianOf2(a, n, b, m));
    return 0;
}