LeetCode第 4 题：寻找两个正序数组的中位数(C++)

4. 寻找两个正序数组的中位数 - 力扣（LeetCode）

中位数的概念就不用细说了。

merge

最直接的思路就是排序后再取中位数，排序的话因为两个数组本来就是有序的，所以只需要merge（没错，就是归并排序的那个merge）两个数组就可以了。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size()+nums2.size();
        vector<int> a(n, 0);
        int i = 0, j = 0, k = 0;
        while(i < nums1.size() && j < nums2.size()){
            if(nums1[i] < nums2[j]) a[k++] = nums1[i++];
            else     a[k++] = nums2[j++];
        }
        while(i < nums1.size()) a[k++] = nums1[i++];
        while(j < nums2.size()) a[k++] = nums2[j++];
        if(n%2) return a[n/2];
        return (a[n/2]+a[n/2-1])*0.5;
    }
};

代码简单直接，可是时间复杂度和空间复杂度都是O(m+n)，因为我们遍历了两个数组而且申请了额外空间。不过该代码优化空间其实很大，我们甚至都不需要遍历完所有数组，也不需要额外数组，用双指针法就可以了。

双指针法

定义两个指针分别指向两个数组的开头，哪个指向的数字小哪个就走一步，遍历次数为$(m+n)/2+1$时中位数就找到了（具体的奇偶需要细分讨论）:

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int len = nums1.size()+nums2.size();
        int pre = 0, cur = 0;//记录当前处理的元素和当前元素的上一个元素
        int l = 0, r = 0;//用来分别遍历两个数组
        for(int i = 0; i <= len/2; ++i){//遍历len/2+1次之后，指向的元素必定是中位数（或者右中位数）
            pre = cur; //pre记录上一次循环的结果（len为偶数的时候即为记录左中位数）
            if(l < nums1.size() && (r >= nums2.size() || nums1[l] < nums2[r]))  cur = nums1[l++];
            else    cur = nums2[r++];
        }
        if(len%2)   return cur;
        return (pre+cur)*0.5;
    }
};

不过虽然空间复杂度为O(1)，但是时间复杂度还是O(m+n)。

可是题目要求的复杂度是O(log(m+n))，log级的时间复杂度，容易让人联想到二分，但是这题有两个数组，应该怎么分呢？

二分

转化为寻找第k大元素的思路，具体还是看官方题解吧，还是很难的：寻找两个正序数组的中位数 - 寻找两个正序数组的中位数 - 力扣（LeetCode）

class Solution {
public:
    int getKthElement(vector<int>& nums1, vector<int>& nums2, int k) {
        /* 主要思路：寻找第 k (k>1) 小的元素，取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
         * nums1 中 <=  pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
         * nums2 中 <=  pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
         * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
         * 这样 pivot 本身最大也只能是第 k-1 小的元素
         * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
         * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
         * 由于"删除"了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
         * 删除并不是真正的删除(当然真要删除也不是不行)，只是记录下标的偏置就可以了
         */
        int m = nums1.size(), n = nums2.size();
        int index1 = 0, index2 = 0;
        while (true) {
            // 当遇到边界的时候
            if (index1 == m) return nums2[index2 + k - 1];
            if (index2 == n) return nums1[index1 + k - 1];
            if (k == 1) return min(nums1[index1], nums2[index2]);//k=1就是寻找最小（第一小）的数，就是两个数组的第一个元素中较小者
            // 正常情况
            int newIndex1 = min(index1 + k / 2 - 1, m - 1); //防止下标越界
            int newIndex2 = min(index2 + k / 2 - 1, n - 1);
            int pivot1 = nums1[newIndex1];
            int pivot2 = nums2[newIndex2];
            if (pivot1 <= pivot2) { //pivot1及其之前的数都删除掉
                k -= newIndex1 - index1 + 1; //更新k的值
                index1 = newIndex1 + 1;//数组nums1的下标偏置增加
            }else {
                k -= newIndex2 - index2 + 1;
                index2 = newIndex2 + 1;
            }
        }
    }

    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int len = nums1.size() + nums2.size();
        if (len % 2 == 1)  //奇数，只有一个中位数，就是第(len+1)/2小的数
            return getKthElement(nums1, nums2, (len + 1) / 2);
        else //偶数，需要寻找左中位数和右中位数，分别是第(len/2)小的数和第(len/2+1)小的数
            return (getKthElement(nums1, nums2, len / 2) + getKthElement(nums1, nums2, len / 2 + 1)) * 0.5;
    }
};