Add Median of Two Sorted Arrays

Author: thanthtooaung-coding

Median of Two Sorted Arrays/README.md

@@ -0,0 +1,36 @@
+# Median of Two Sorted Arrays
+
+## LeetCode Problem
+- Problem Number: 4
+- Problem Link: https://leetcode.com/problems/median-of-two-sorted-arrays/
+- Difficulty: Hard
+- Topics: Array, Binary Search, Divide and Conquer
+
+## Problem Description
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return the median of the two sorted arrays.
+
+The overall run time complexity should be O(log (m+n)).
+
+## Examples
+
+### Example 1:
+```
+Input: nums1 = [1,3], nums2 = [2]
+Output: 2.00000
+Explanation: merged array = [1,2,3] and median is 2.
+```
+
+### Example 2:
+```
+Input: nums1 = [1,2], nums2 = [3,4]
+Output: 2.50000
+Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+```
+
+## Constraints
+- nums1.length == m
+- nums2.length == n
+- 0 <= m <= 1000
+- 0 <= n <= 1000
+- 1 <= m + n <= 2000
+- -10⁶ <= nums1[i], nums2[i] <= 10⁶

Median of Two Sorted Arrays/Solution.java

@@ -0,0 +1,35 @@
+class Solution {
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        if (nums1.length > nums2.length) {
+            return findMedianSortedArrays(nums2, nums1);
+        }
+        
+        int m = nums1.length;
+        int n = nums2.length;
+        int low = 0, high = m;
+        
+        while (low <= high) {
+            int partition1 = (low + high) / 2;
+            int partition2 = (m + n + 1) / 2 - partition1;
+            
+            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];
+            
+            if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
+                if ((m + n) % 2 == 1) {
+                    return Math.max(maxLeft1, maxLeft2);
+                }
+                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 or invalid.");
+    }
+}

Two Sum/README.md

@@ -39,36 +39,4 @@ Output: [0,1]
 - 2 <= nums.length <= 10⁴
 - -10⁹ <= nums[i] <= 10⁹
 - -10⁹ <= target <= 10⁹
-- Only one valid answer exists
-
-## Solution Approach
-There are two main approaches to solve this problem:
-
-### 1. Hash Table Approach (Optimal)
-- Time Complexity: O(n)
-- Space Complexity: O(n)
-- Algorithm:
-  1. Create a HashMap to store complement values
-  2. For each number in the array:
-     - Calculate complement (target - current number)
-     - If complement exists in HashMap, return [complementIndex, currentIndex]
-     - Add current number and its index to HashMap
-
-### 2. Brute Force Approach
-- Time Complexity: O(n²)
-- Space Complexity: O(1)
-- Algorithm:
-  1. Use nested loops to try every possible pair
-  2. Check if any pair sums to target
-  3. Return indices when found
-
-## Common Pitfalls
-1. Using the same element twice
-2. Not considering negative numbers
-3. Forgetting to check if complement exists before adding to HashMap
-4. Returning wrong order of indices
-
-## Related Problems
-- 167: Two Sum II - Input Array Is Sorted
-- 170: Two Sum III - Data structure design
-- 653: Two Sum IV - Input is a BST
+- Only one valid answer exists