力扣刷题-----寻找两个有序数组的中位数

题目：
给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

算法：二分查找

最关键的步骤是找到分割线，中位数只与分割线两侧的元素有关

对于总长度奇偶问题可以合并解决

第二个条件需要调节分割线

四种特殊情况

代码如下：

public class Solution {

    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1.length > nums2.length) {   //较短的设置为数组nums1
            int[] temp = nums1;
            nums1 = nums2;
            nums2 = temp;
        }

        int m = nums1.length;
        int n = nums2.length;

        // 分割线左边的所有元素需要满足的个数 m + (n - m + 1) / 2;
        int totalLeft = (m + n + 1) / 2;

        // 在 nums1 的区间 [0, m] 里查找恰当的分割线，
        // 使得 nums1[i - 1] <= nums2[j] && nums2[j - 1] <= nums1[i]
        //分割线一左<=分割线二右并且分割线二左<=分割线一右
        
        //二分查找过程
        int left = 0;
        int right = m;

        //写法一
        while (left < right) {
            int i = left + (right - left + 1) / 2;
            int j = totalLeft - i;
            if (nums1[i - 1] > nums2[j]) {
                // 下一轮搜索的区间 [left, i - 1]
                right = i - 1;
            } else {
                // 下一轮搜索的区间 [i, right]
                left = i;
            }
        }

        //写法二
        //while (left < right) {
        //    int i = left + (right - left) / 2;
        //    int j = totalLeft - i;
        //    if (nums2[j - 1] > nums1[i]) {
            // 下一轮搜索的区间 [i + 1, right]
        //         left = i + 1;
        //     } else {
                // 下一轮搜索的区间 [left, i]
        //         right = i;
        //     }
        //  }

        int i = left;
        int j = totalLeft - i;

        //越界讨论
        int nums1LeftMax = i == 0 ? Integer.MIN_VALUE : nums1[i - 1];
        int nums1RightMin = i == m ? Integer.MAX_VALUE : nums1[i];
        int nums2LeftMax = j == 0 ? Integer.MIN_VALUE : nums2[j - 1];
        int nums2RightMin = j == n ? Integer.MAX_VALUE : nums2[j];

        if (((m + n) % 2) == 1) {
            return Math.max(nums1LeftMax, nums2LeftMax);
        } else {
            return (double) ((Math.max(nums1LeftMax, nums2LeftMax) + Math.min(nums1RightMin, nums2RightMin))) / 2;
        }
    }
}

复杂度分析：

时间复杂度：O(log min(m,n))，其中m和n分别是数组 nums1 和nums2的长度。

空间复杂度：O(1)