力扣hot100：4. 寻找两个正序数组的中位数（归并排序/二分/双指针）

一、暴力排序

二、归并排序

三、双指针

四、二分查找

如果本题不说明时间复杂度应该为O(log(m+n)，那么本题应该是一个简单题，解决的方法有很多。这里先列举出普通方法，再来讨论二分。

一、暴力排序

不管啦，直接纯暴力，合并之后排序了！O((n+m)log(m+n))

class Solution {
public:double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {vector<int> num(nums1);num.insert(num.end(),nums2.begin(),nums2.end());sort(num.begin(),num.end());return (num[num.size()/2]+num[(num.size()-1)/2])/2.0;}
};

二、归并排序

我们在学习归并排序的时候，解决过一个问题，当两个数组是有序的时，对他们进行排序，实际上只需要O(n+m)的时间就能解决。指向两个数组中较小的那一个，依次放入一个新的数组，最终就会得到一个排好序的数组。
class Solution {
public:double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {vector<int> num;int n=nums1.size(),m=nums2.size();num.reserve(n+m);int left=0,right=0;while(left<n&&right<m){if(nums1[left]<nums2[right]){num.emplace_back(nums1[left++]);}else num.emplace_back(nums2[right++]);}if(left<n) num.insert(num.end(),nums1.begin()+left,nums1.end());else num.insert(num.end(),nums2.begin()+right,nums2.end());return (num[num.size()/2]+num[(num.size()-1)/2])/2.0;}
};

三、双指针

用双指针找到中位数，不需要合并两个有序数组，只要找到中位数的位置即可。由于两个数组的长度已知，因此中位数对应的两个数组的下标之和也是已知的。维护两个指针，初始时分别指向两个数组的下标 0的位置，每次将指向较小值的指针后移一位（如果一个指针已经到达数组末尾，则只需要移动另一个数组的指针），直到到达中位数的位置。实际上你可以想象成两个数组已经合并排序，但是指针移动时是在各自的数组元素中移动的，因此双指针找中位数位置，只需要按照以上方法就能找到，每移动一次表示一个数已经归为（而且只有一个数）。

用归并排序理解：双指针和归并排序的区别在于？？实际上你发现归并排序改一改就可以找到中位数呢？怎么了呢？你依次放入一个新的数组，实际上由于你知道中位数的位置，那么你放入的位置刚好是中位数的位置不就是中位数了吗？？
class Solution {
public:double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {int n = nums1.size(), m = nums2.size();int total = (n + m)>>1;int left = 0, right = 0, last = 0, current = 0;for (int i = 0; i <= total; i++) {last = current; // 保存上一次的current值，以至于到了i==total时，last存的是total-1位置的值if (left < n && (right >= m || nums1[left] < nums2[right])) {current = nums1[left++];} else {current = nums2[right++];}}if ((n+m) % 2 == 0) {return (last + current) / 2.0;} else {return current;}}
};
实现说明：

这份代码进行了优化，实际上同一个算法，不同人来写会有不同的难度，比如上述代码实际上比较容易实现，我们用current来存储第i小的元素，那么遍历到i==total自然而然current就是第total小的元素。可能有的人会这样写，只有到total才存储第total小的元素，其他时候不存，那么这样写会写判断更复杂了。

并且这里的if判断很有讲究，由于这里只有两种情况，因此我们只需要写出其中满足其中一种情况的if语句，那么不满足这个情况自然而然会执行另一种情况的语句。所以这里我们在写if时，只需要思考满足current = nums1[left++]的条件即可！

四、二分查找

非常牛的方法。

中位数的位置为：k= mid1=(m+n)/2-1或mid2=(m+n)/2，即有k-1个数是比它小的。由于整个数组是顺序的，我们能否一次确定某个位置的数只有k-2个数比它小，而不用再考虑了呢？如何确定？

我们令x=k/2-1（因为nums[i]，则nums[i]之前一共i个数），我们比较nums1[x]和nums2[x]的大小：

①如果nums1[x]＞nums2[x]，则说明nums2[x]的数最多只有k/2-1+k/2-1<=k-2个数比它小，因此nums[0]~nums[x]都不需要再考虑了，由于我们已经筛了k/2个数，不考虑这些数。接下来我们需要寻找的是第k-k/2个数，令k=k-k/2 （达到了二分的效果）

②如果nums1[x]<nums2[x] 和①类似

③如果nums1[x]==nums2[x]，则对于nums1[x]和nums2[x]而言，都必然有，最多只有1+k/2-1+k/2-1<=k-2个数比它小或等于（我们必须要找到k-1个比它小于等于的），因此去掉任何一个都行。

④当某个数组的下标越界了，那就缩小比对范围，比对一次后，去⑤

⑤如果另外一个数组为空，直接返回另一个数组的第k小元素。

⑥如果k=1，即我们需要找到0个比它小的，那么直接返回两个数组首下标的最小的那个即可。

朴素实现：
class Solution {
public:double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {if(nums1.size()==0) return (nums2[nums2.size()/2]+nums2[(nums2.size()-1)/2])/2.0;if(nums2.size()==0) return (nums1[nums1.size()/2]+nums1[(nums1.size()-1)/2])/2.0;int mid=(nums1.size()+nums2.size())>>1;//mid表示k小的元素，"下标是k-1"if((nums1.size()+nums2.size())%2==1){return findk(nums1,nums2,mid+1,0,0);}else{return (findk(nums1,nums2,mid+1,0,0)+findk(nums1,nums2,mid,0,0))/2.0;}}int findk(vector<int>& nums1,vector<int>&nums2,int k,int start1,int start2) {//找到第k小的元素，前面有k-1个更小的if(start1>=nums1.size()) return nums2[start2+k-1];//下标直接越界咯if(start2>=nums2.size()) return nums1[start1+k-1];if(k==1) return min(nums1[start1],nums2[start2]);//这个一定要在上面的后面，因为可能start1和start2已经越界！！int x=k/2-1;if(start1+x>=nums1.size()) {//nums1不够用了x=nums1.size()-start1-1;//最多比对到nums1.size()-1if(nums1[start1+x]<=nums2[start2+x]) {//k/2-1+k/2-1<=k-2 nums1已经废了k=k-x-1;//筛去了x+1个数，现在寻找的是第k-x-1小的数了return nums2[start2+k-1];}else {start2=start2+x+1;//nums2[start2+x]被筛去了k=k-x-1;return findk(nums1,nums2,k,start1,start2);}}if(start2+x>=nums2.size()) {//nums2不够用了x=nums2.size()-start2-1;//最多比对到nums2.size()-1if(nums1[start1+x]>=nums2[start2+x]) {//k/2-1+k/2-1<=k-2 nums2已经废了k=k-x-1;//筛去了x+1个数，现在寻找的是第k-x-1小的数了return nums1[start1+k-1];}else {start1=start1+x+1;//nums1[start1+x]被筛去了k=k-x-1;return findk(nums1,nums2,k,start1,start2);}}if(nums1[start1+x]>=nums2[start2+x]) {k=k-x-1;start2=start2+x+1;return findk(nums1,nums2,k,start1,start2);}else {k=k-x-1;start1=start1+x+1;return findk(nums1,nums2,k,start1,start2);}return 0;}
};
高级实现：

（1）我们始终保持nums1剩余部分最短，这样保证了代码不需要多次判断

（2）保持nums1剩余最短，只需要判断nums1是否越界

（3）将下标越界和普通查找合并，实际上我们每次都能保证前面元素一共k-2个元素时筛选，即使其中有个越界了，我们也可以保证，这样可以更快。
class Solution {
public:double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {if(nums1.size()==0) return (nums2[nums2.size()/2]+nums2[(nums2.size()-1)/2])/2.0;if(nums2.size()==0) return (nums1[nums1.size()/2]+nums1[(nums1.size()-1)/2])/2.0;int mid=(nums1.size()+nums2.size())>>1;//mid表示k小的元素，"下标是k-1"if((nums1.size()+nums2.size())%2==1){return findk(nums1,nums2,mid+1,0,0);}else{return (findk(nums1,nums2,mid+1,0,0)+findk(nums1,nums2,mid,0,0))/2.0;}}int findk(vector<int>& nums1, vector<int>& nums2, int k, int start1, int start2) {// 确保nums1是较短的数组if (nums1.size() - start1 > nums2.size() - start2) return findk(nums2, nums1, k, start2, start1);// 检查边界条件if (start1 >= nums1.size()) return nums2[start2 + k - 1];if (k == 1) return min(nums1[start1],nums2[start2]);// 递归查找int k1 = min(start1 + k / 2, (int)nums1.size()) - start1;//nums1拉满int k2 = k - k1;//k2=k1也是行的；不过可以：nums2根据nums1选的数量调整，保证 k1+k2=k ,这样一定能保证前面有k-2个，减少匹配数量if (nums1[start1 + k1 - 1] < nums2[start2 + k2 - 1])return findk(nums1, nums2, k - k1, start1 + k1, start2);elsereturn findk(nums1, nums2, k - k2, start1, start2 + k2);
}
};