本文正在参加「Java主题月 - Java 刷题打卡」，详情查看 活动链接

题目

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。 示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000

题解

题解一：合并有序列表

思路

根据中位数的定义，对于一个长度为 len 的有序数组A，如果数组长度为奇数，中位数为A[len/2]；如果数组长度为偶数，中位数为 A[len/2] 与 A[len/2+1] 的算术平均值。

题目已知条件是两个有序数组，我们将两个有序数组合并成一个有序数组，再利用上述思路就能找出中位数。

代码

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int[] merge = new int[nums1.length + nums2.length];
        int index = 0;
        int index1 = 0;
        int index2 = 0;
        while (index1 < nums1.length || index2 < nums2.length){
            if(index1 >= nums1.length){
                // move index2
                merge[index++] = nums2[index2++];
            }else if(index2 >= nums2.length){
                // move index1
                merge[index++] = nums1[index1++];
            }else {
                if(nums1[index1] < nums2[index2]){
                    merge[index++] = nums1[index1++];
                }else {
                    merge[index++] = nums2[index2++];
                }
            }
        }
        int mid = merge.length / 2;
        return merge.length % 2 == 0 ? (merge[mid] + merge[mid-1])*1.0 / 2 : merge[mid];
    }

复杂度分析

假设两个数组的长度为m和n。

时间复杂度：O(m+n)。 将两个列表合并成一个列表，需要遍历两个列表的所有元素，复杂度为O(m+n),有序列表找中位数是常数时间的复杂度,所以总的时间复杂度为O(m+n).

空间复杂度：O(m+n)。需要一个数组存储排序后的元素。

题解二：二分查找

思路

可以将该问题转化为求"两个有序数组中第K大的元素"，如果两个数组总长度为奇数，K为(m+n)/2 + 1;如果两个数组的总长度为偶数，则求第 (m+n)/2 + 1 大和第 (m+n)/2+2 大的元素。

对于查找第K大的元素，由于数组有序，可以利用二分查找的思路减少查找次数。

用一个例子来说明上述思路，假设两个有序数组如下

A: 1 3 4 9
B: 1 2 3 4 5 6 7 8 9

两个有序数组的长度分别是 4 和 9，长度之和是 13，中位数是两个有序数组中的第 7 个元素，因此需要找到第 k=7 个元素。 比较两个有序数组中下标为 k/2-1=2k/2−1=2 的数，即 A[2] 和 B[2]，如下面所示：

A: 1 3 4 9
       ↑
B: 1 2 3 4 5 6 7 8 9
       ↑

由于 A[2]>B[2]，因此排除B[0] 到B[2]，即数组B 的下标偏移（offset）变为 3，同时更新 k 的值：k=k-k/2=4

下一步寻找，比较两个有序数组中下标为 k/2-1=1的数，即 A[1] 和 B[4]，如下面所示，其中方括号部分表示已经被排除的数。

A: 1 3 4 9
     ↑
B: [1 2 3] 4 5 6 7 8 9
             ↑

由于A[1]<B[4]，因此排除 A[0] 到 A[1]，即数组A 的下标偏移变为 2，同时更新 kk 的值：k=k-k/2=2。

下一步寻找，比较两个有序数组中下标为 k/2-1=0 的数，即比较 A[2] 和 B[3]，如下面所示，其中方括号部分表示已经被排除的数

A: [1 3] 4 9
         ↑
B: [1 2 3] 4 5 6 7 8 9
           ↑

由于 A[2]=B[3]，根据之前的规则，排除 A 中的元素，因此排除 A[2]，即数组 A 的下标偏移变为 3，同时更新 k 的值： k=k-k/2=1。

由于 k 的值变成 1，因此比较两个有序数组中的未排除下标范围内的第一个数，其中较小的数即为第 k 个数，由于 A[3]>B[3]，因此第 k 个数是B[3]=4。

A: [1 3 4] 9
           ↑
B: [1 2 3] 4 5 6 7 8 9
           ↑

我们还可以将总数组长度为奇数和偶数的情况合并为一种，对于偶数的情况，相当于多做了一次运算，但是可以简化代码逻辑。

代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int kTh1 = (nums1.length + nums2.length + 1)/2;
        int kTh2 = (nums1.length + nums2.length + 2)/2;
        return (getKth(nums1,nums2,kTh1) + getKth(nums1,nums2,kTh2))/2.0;

    }

    private int getKth(int[] nums1,int[] nums2,int k){
        int len1 = nums1.length;
        int len2 = nums2.length;
        int index1 = 0;
        int index2 = 0;
        int kThElement = 0;
        while (true){
            // boundary
            if(index1 == len1){
                return nums2[index2 + k - 1];
            }
            if(index2 == len2){
                return nums1[index1 + k - 1];
            }
            if(k==1){
                return Math.min(nums1[index1],nums2[index2]);
            }

            // normal
            int half = k/2;
            int newIndex1 = Math.min(index1 + half,len1) - 1;
            int newIndex2 = Math.min(index2 + half,len2) - 1;
            if(nums1[newIndex1] <= nums2[newIndex2]){
                k -= newIndex1 - index1 + 1;
                index1 = newIndex1 + 1;
            }else {
                k -= newIndex2 - index2 + 1;
                index2 = newIndex2 + 1;
            }
        }
    }
}

复杂度分析

时间复杂度：O(log(m+n))。初始时有 k=(m+n)/2 或 k=(m+n)/2+1，每一轮循环可以将查找范围减少一半，因此时间复杂度是 O(log(m+n))

空间复杂度：O(1)。