Add MedianOfTwoSortedArrays.java new algorithm

Author: Hardvan

src/main/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArrays.java

@@ -0,0 +1,50 @@
+package com.thealgorithms.divideandconquer;
+
+public class MedianOfTwoSortedArrays {
+
+    /**
+     * Finds the median of two sorted arrays in logarithmic time.
+     *
+     * @param nums1 the first sorted array
+     * @param nums2 the second sorted array
+     * @return the median of the combined sorted array
+     * @throws IllegalArgumentException if the input arrays are not sorted
+     */
+    public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        if (nums1.length > nums2.length) {
+            return findMedianSortedArrays(nums2, nums1); // Ensure nums1 is the smaller array
+        }
+
+        int m = nums1.length;
+        int n = nums2.length;
+        int low = 0;
+        int high = m;
+        while (low <= high) {
+            int partition1 = (low + high) / 2; // Partition in the first array
+            int partition2 = (m + n + 1) / 2 - partition1; // Partition in the second array
+
+            int maxLeft1 = (partition1 == 0) ? Integer.MIN_VALUE : nums1[partition1 - 1];
+            int minRight1 = (partition1 == m) ? Integer.MAX_VALUE : nums1[partition1];
+            int maxLeft2 = (partition2 == 0) ? Integer.MIN_VALUE : nums2[partition2 - 1];
+            int minRight2 = (partition2 == n) ? Integer.MAX_VALUE : nums2[partition2];
+
+            // Check if partition is valid
+            if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
+                // If combined array length is odd
+                if ((m + n) % 2 == 1) {
+                    return Math.max(maxLeft1, maxLeft2);
+                }
+                // If combined array length is even
+                else {
+                    return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2.0;
+                }
+            } else if (maxLeft1 > minRight2) {
+                high = partition1 - 1;
+            } else {
+                low = partition1 + 1;
+            }
+        }
+
+        throw new IllegalArgumentException("Input arrays are not sorted");
+    }
+}

src/test/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArraysTest.java

@@ -0,0 +1,32 @@
+package com.thealgorithms.divideandconquer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class MedianOfTwoSortedArraysTest {
+
+    @Test
+    void testFindMedianSortedArrays() {
+        // Test case 1: Arrays of equal length
+        assertEquals(2.5, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{1, 3}, new int[]{2, 4}));
+
+        // Test case 2: Arrays of different lengths
+        assertEquals(2.0, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{1, 3}, new int[]{2}));
+
+        // Test case 3: Arrays with even total length
+        assertEquals(2.5, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{1, 2, 8}, new int[]{3, 4, 5, 6, 7}));
+
+        // Test case 4: Arrays with odd total length
+        assertEquals(3.0, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{1, 2, 8}, new int[]{3, 4, 5}));
+
+        // Test case 5: Single element arrays
+        assertEquals(2.0, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{1}, new int[]{3}));
+
+        // Test case 6: Empty arrays
+        assertEquals(0.0, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{}, new int[]{0}));
+
+        // Test case 7: Same element arrays
+        assertEquals(2.0, MedianOfTwoSortedArrays.findMedianSortedArrays(new int[]{2, 2, 2}, new int[]{2, 2, 2}));
+    }
+}