LeetCode（4.寻找两个有序数组的中位数[困难]）—二分法

题目

给定两个大小为 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

题目解析及优化

1. 如果不看时间复杂度的话，这是以到比较简单的题，常见的做法有：

   • 两序列合并为一个序列，排序，找中位数。（没有利用两个正序的条件）
   • 用双指针分别指向两个正序的开头，指向元素小的移动，寻找中位数。（比第一种方法好一些，但是时间复杂度依旧是O(m+n)）

2. 如果时间复杂度要达到log级别的，应该想到二分法去解决。其实我们的主要难点是如何寻找第k小的数字，解决这个问题之后，中位数就只是一个总长度奇偶的两个if-else语句了。

   首先我们要明白第k小的数的含义是什么，是排在第k个位置的数，再换句话说，整个序列要有k-1比他小，发现问题了？我们只要找到一个数，没有一半的数比它小，那么它和比它小的就一定不是第k小的数。

   举个例子，寻找第k小的数字，如果一个数a最多只有k-2个数比它小，那么a是第k-1小的数字，那么a和比a小的就可以直接排除。排除掉k-1个数字之后，接下来寻找的就应该是剩余数组的 (k-(k-1)) = 1个数字。这就是大体的思路。

   举个例子加深一下理解，数组1:1,3,5,7,9。数组2:2,4,6,8;

   • 首先我们明确应该找第5小的数字，同时取两个数组里面的第k/2项，即3和4，3<4，就算4前面的2小于3，最多也只能有(k/2-1+k/2-1) = k-2 项（这里由于是奇数会少一项为2）比3小，那么3和3之前的1被排除。

     • 想一想为什么不一起排除4前面的2呢？

       因为目前只能排除3和比3小的，3和4前面的2在一般情况下的大小关系是不确定的，不能随意排除。

   • 之后就变成了寻找数组1:5,7,9;和数组2:2,4,6,8中的第3小的数字，比较2和5，排除2

   • 寻找数组1:5,7,9;和数组2:,4,6,8中的第2小的数字，比较4和5，排除4；

   • 寻找数组1:5,7,9;和数组2:6,8中的第1小的数字，比较6和5，取出5即是答案。

   思想和方法有了，之后是代码如何写，首先是循环结束的条件：

   • 当一个数组没有元素之后，直接返回另一个数组的所需要的第K个数即可。（这里的K和开始的k不是一个k）
   • 当两数组都一直有元素的时候，当k为1的时候，返回两数组第一个元素的较小值。

   接着就是下标的移动，当第k/2项较小的那个数组的初始下标要更新，最后是k值的更新。

   代码如下：

   double find_k_num(vector<int> &nums1, vector<int> &nums2, int k) {
       int index1 = 0, index2 = 0, l1 = nums1.size(), l2 = nums2.size();
       while (true) {
           if (index1 == l1)return nums2[index2 + k - 1];
           if (index2 == l2)return nums1[index1 + k - 1];
           if (k == 1) {
               return min(nums1[index1], nums2[index2]);
           }
           int half_k = k / 2;
           int newindex1 = min(index1 + half_k - 1, l1 - 1);
           int newindex2 = min(index2 + half_k - 1, l2 - 1);
           int num1 = nums1[newindex1];
           int num2 = nums2[newindex2];
           if (num1 <= num2) {
               k = k - newindex1 + index1 - 1;
               index1 = newindex1 + 1;
           } else {
               k = k - newindex2 + index2 - 1;
               index2 = newindex2 + 1;
           }
       }
   }
   
   double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) {
       int k = nums1.size() + nums2.size();
       if (k % 2 == 1) {
           return find_k_num(nums1, nums2, k / 2 + 1);
       } else {
           return (find_k_num(nums1, nums2, k / 2) + find_k_num(nums1, nums2, k / 2 + 1)) / 2;
       }
   }
   

   在自己写这个代码的时候有几点困难踩坑的地方：

   • 在判断返回条件的时候，k==1这个条件要放在前两个之后；
   • 第一个函数最好写成double类型的返回值，否则涉及小数点有时会出错；

3. 划分数组

   我们回归到中位数的性质上，上次用的性质是中位数把数组分为两个集合，一个都比中位数小，一个都比中位数大。这次用到的性质是，中位数把数组分为元素数量相等或者差距为1的集合的两个集合，一个集合中的最大值小于等于另一个集合的最小值。

   我们假设数组A的长度为m，数组B的长度为n，且A的长度小于B的长度。设定整数0<i<=m,0<j<=n（这里可以等于0和长度是可以将整个数组都划分到右或者左边）

   用 i 将A数组划分为两个部分 A_left , A_right , j将B分为 B_left 和 B_right 。由于A的长度小于B的长度，所以不管i取多少，总有j存在使得

   len ( A_left + B_left ) = len ( A_right + B_right ) （+1总长度为奇数的时候）

   其实i和j就是一个此消彼长的过程，二者变化的时候始终保持着划分的左右两部分长度满足上式。

   接下来就是左边总小于右边的问题了，其实只要两个等式成立即可。

   A [ i - 1 ] < B [ j ]

   B [ j - 1 ] < A [ i ]

   其实问题现在就变成了在A中找一个合适的点满足上述式子即可。如果从头到尾遍历的话时间复杂度又是min ( m , n )，其实找点的时候可以用二分法查找。

   继续代码的写法：

   • 由于必须在较短的数组里面寻找，所以如果不符合条件，要交换AB；
   • 用二分法找i的时候，i 和 j 满足式子j = ( m+ n + 1 ) / 2 − i ,
   • 当i和j为0或者对应数组的长度时，处理月结问题，保证不会最值大小的判断，就是取相应的无穷大和无穷小即可。
   • 对于边界收缩的判断，举个例子：如果A_left的最大值大于B_right的最小值，那么 i 就取的过大了，收缩右边界，否则是合理的，收缩左边界即可，在收缩左边界的时候，注意最值的保存。

   代码如下：

   class Solution {
   public:
       double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) {
           if (nums1.size() > nums2.size()) {
               return findMedianSortedArrays(nums2, nums1);
           }
           int m = nums1.size(), n = nums2.size();
           int left = 0, right = nums1.size();
           int left_max, right_min;
           while (left <= right) {
               int i = (left + right) / 2;
               int j = (m + n + 1) / 2 - i;
               int num_i_1 = i == 0 ? -10000000 : nums1[i - 1];
               int num_i = i == m ? 10000000 : nums1[i];
               int num_j_1 = j == 0 ? -10000000 : nums2[j - 1];
               int num_j = j == n ? 10000000 : nums2[j];
               if (num_i_1 > num_j) {
                   right = i - 1;
               } else {
                   left_max = max(num_i_1, num_j_1);
                   right_min = min(num_i, num_j);
                   left = i + 1;
               }
   
           }
           return (m + n) % 2 == 0 ? (left_max + right_min) / 2.0 : left_max;
       }
   };
   

   上述解法的时间复杂度是O(log(min(m,n))) ,比第一种解法还要省时间。

心得及总结

• 本题作为一道困难难度的题目，难度在于如何将时间复杂度降下来，而解题的关键是如何运用题中的正序的条件，这道题的主要思想就是二分法，而二分法的使用大多要求集合排序是有规律的。理解本题之后对于二分法也会有更深的理解；
• 对于一道题而言，要对题目的每个信息理解透彻，例如本题中的中位数到底可以怎么用，如何转化成用编程语言表达的大小，理解的程度困难会直接影响题目的解答；
• 在看完大神的思路之后，代码一定要自己写一次，写的时候会发现很多细节地方，这些细节可以帮助我们的思考变得更细致；
• 在第一种解法中，三种结束的条件的先后顺序是有讲究的，以后在遇到多种结束条件的时候要多思考顺序是否可以互换；
• 函数的返回值类型，有时候需要格外注意，像上面第一种解法的时候，虽然findMedianSortedArrays的返回值是double类型的，但是奈何里面的函数是int类型的函数而导致输出的其实是去过尾的整数导致的错误。