LeetCode4-寻找两个正序数组的中位数

题目

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

算法的时间复杂度应该为 O(log (m+n)) 。

示例 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

提示：

• nums1.length == m
• nums2.length == n
• 0 <= m <= 1000
• 0 <= n <= 1000
• 1 <= m + n <= 2000
• -106 <= nums1[i], nums2[i] <= 106

方法1

将两个数组合并并排序，根据数组大小的奇偶数，找到中位数

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int[] nums = new int[m + n];
        
        //将数组1的值传入新建数组中
        for(int i = 0;i < m;i++){
          nums[i] = nums1[i];
        }
        //将数组2的值传入新建数组中
        for(int i = 0;i < n;i++){
          nums[m + i] = nums2[i];
        }
    
        //新建数组排序
        Arrays.sort(nums);
        int l = nums.length;
        double medium = 0;
        //判断数组长度奇偶性
        if(length % 2 == 0){
          medium = (nums[l/2 - 1] + nums[l/2])/2;
        }else{
          medium = nums[(l -1)/2];
        }
         
        return medium;  
    }
}

1. 复制数组 nums1 到新数组 nums：时间复杂度为 O(m)，其中 m 是 nums1 的长度。
2. 复制数组 nums2 到新数组 nums：时间复杂度为 O(n)，其中 n 是 nums2 的长度。
3. 对新数组 nums 进行排序：时间复杂度为 O((m+n)log⁡(m+n))，因为 Arrays.sort() 在最坏情况下使用的是快速排序，其时间复杂度为 O(nlog⁡n)，这里 nn 是数组的长度。

将这些步骤的时间复杂度相加，得到总的时间复杂度：

O(m)+O(n)+O((m+n)log⁡(m+n))

在时间复杂度的分析中，我们通常只保留最高阶的项，因为当输入规模增大时，最高阶的项将成为主导因素。因此，上述总时间复杂度可以简化为：

O((m+n)log⁡(m+n))

方法2

补充：快速判断数字是否为奇数的方式-len & 1

• 如果 len 是奇数，其二进制表示的最后一位是1，那么 len & 1 的结果是1。
• 如果 len 是偶数，其二进制表示的最后一位是0，那么 len & 1 的结果是0。

• len & 1：这个表达式会计算 len 和 1 的位与结果。
• 位与操作 & 会比较两个数的二进制表示的每一位，只有当两个比较的位都是1时，结果位才是1，否则是0。
• 因为 1 的二进制表示的最后一位是1，所以 len & 1 的结果实际上取决于 len 的最后一位是否为1。

不用合并两个数组，判断两个数组当前位置的大小，当前位置小的数组就后移一位，当前位置大的数组保持不变；其次假设合并后数组的长度是len,如果是奇数，我们需要知道第（len + 1）/2个数字，如果是偶数则需要知道第len/2和（len+1）/2两个数，所以无论是奇数还是偶数都必须遍历到第len/2 +1位

public double findMedianSortedArrays(int[] A,int[] B){
  //计算合并后数组的长度
  int m = A.length();
  int n = B.length();
  int len = m + n;

  int left = -1,right = -1;//用于记录当前位置的左右两个数
  int aStart = 0,bStart = 0;//用于记录两个数组当前进展到哪个位置

  //开始遍历两个数组，只遍历len/2次
  for(int i = 0;i < len/2 ;i++){
    //每向后移动一位，right则把值赋给left,而right去存储两数组新的值
    left = right;
    //比较两数组当前位置的大小，决定哪个数组的位置右移
    if( aStart < m && (bStart >= n || A[astart] < B[bstart])){
      right  = A[astart];
      astart++;
    }else{
      right = B[bstart];
      bstart++;
    }

    //判断数组长度奇偶性
    if((len & 1) == 0){
      return (left + right)/2;
    }else{
      return right;
    }
}

时间复杂度：遍历len/2+1次，T=O（m+n）

方法3

采用递归的思路，递归出口是当k = 1或其中一个数组长度是0

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int n = nums1.length;
    int m = nums2.length;
    int left = (n + m + 1) / 2;
    int right = (n + m + 2) / 2;
    //将偶数和奇数的情况合并，如果是奇数，会求两次同样的 k 。
    return (getKth(nums1, 0, n - 1, nums2, 0, m - 1, left) + getKth(nums1, 0, n - 1, nums2, 0, m - 1, right)) * 0.5;  
}
    
    private int getKth(int[] nums1, int start1, int end1, int[] nums2, int start2, int end2, int k) {
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;
        //让 len1 的长度小于 len2，这样就能保证如果有数组空了，一定是 len1 
        if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);
        if (len1 == 0) return nums2[start2 + k - 1];

        if (k == 1) return Math.min(nums1[start1], nums2[start2]);

        int i = start1 + Math.min(len1, k / 2) - 1;
        int j = start2 + Math.min(len2, k / 2) - 1;

        if (nums1[i] > nums2[j]) {
            return getKth(nums1, start1, end1, nums2, j + 1, end2, k - (j - start2 + 1));
        }
        else {
            return getKth(nums1, i + 1, end1, nums2, start2, end2, k - (i - start1 + 1));
        }
    }