二分查找（三）

2.练习题

5）力扣https://leetcode.cn/problems/single-element-in-a-sorted-array/解题思路：

最简单的方法就是把数组里所有数一次异或，最后得到的结果就是单一元素，因为任何一个数a, a^a = 0, a^0=a.

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {

        int res = 0;
        for(auto n:nums){
            res ^= n;
        }
        return res;
    }
};

这样时间复杂度是O(n)，题目要求O(log n)，所以还是要用二分查找。

针对有序数组二分查找，有很多变形题，基本思路就是分情况讨论，这道题需要考虑选择[left, mid)区间还是(mid,right]区间，拿几个例子分析一下，可以发现这取决于mid元素是否与前一个元素相等，以及左右两个区间的元素数量。

需要注意的是取区间时，要保持数组原有特性，维持只有一个单一元素，所以两种情况下边界取值不一样。

代码：

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int left = 0, right = nums.size()-1, mid;

        while(left<right){
            mid = left + (right-left)/2;
            if(nums[mid]!=nums[mid+1] && nums[mid]!=nums[mid-1]){
                return nums[mid];
            }

            if((right-left)/2%2 == 0 ){
                if(nums[mid]==nums[mid-1]){
                    right = mid - 2;
                }else{
                    left = mid + 2;
                }
            }else{
                if(nums[mid]==nums[mid-1]){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }
             
        }
        return nums[left];
    }
};

 

6)力扣https://leetcode.cn/problems/median-of-two-sorted-arrays/

这题求中位数，可以转化成求第k个数。利用二分查找，每次舍弃较小的那k/2长度的区间。

注意点：k表示第k个数，从1开始计数，我一开始的写法是从0开始计数，导致当k=1时，k=k-k/2这一步一直停留在1，无法继续迭代。

代码：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        if((m+n)%2==1){
            return find(nums1,0,nums2,0,(m+n)/2+1);
        }else{
             return (find(nums1,0,nums2,0,(m+n)/2+1) + 
             find(nums1,0,nums2,0,(m+n)/2))/2.0;   
        }
    }

    double find(vector<int>& nums1,int s1,  vector<int>& nums2, int s2, int k){
  
        if(s1>=nums1.size()){
            return nums2[s2+k-1];
        }
        if(s2>=nums2.size()){
            return nums1[s1+k-1];
        }
        if(k==1){
            return min(nums1[s1], nums2[s2]);
        }
        int e1 = nums1.size()-1, e2 = nums2.size()-1;
        int mid1 =  (s1+k/2-1)<=e1?nums1[(s1+k/2-1)]:INT_MAX;
        int mid2 =  (s2+k/2-1)<=e2?nums2[(s2+k/2-1)]:INT_MAX;
       
        if(mid1<mid2){
            s1 = s1+k/2;
        }else{
            s2 = s2+k/2;
        }
        return find(nums1,s1,nums2,s2,k-k/2);

    }
};