Leetcode-二分查找

二分有两个模板，大部分题目都可以靠这两个模板衍生。

在排好序的数组nums中找到target的下标
模板1：找最后一个满足条件的数

while(l<r){
	int mid=(l+r)>>1;
	if(nums[mid]>=target) r=mid;  
	else l=mid+1;
}

模板2：找第一个满足条件的数

while(l<r){
	int mid=(l+r+1)>>1;
	if(nums[mid]<=target) l=mid;
	else r=mid-1;
}

stl中的二分查找：

1. lower_bound(arr[],arr[]+size,const ,val)返回第一个大于等于val的下标
2. upper_bound(arr[],arr[]+size,const,val)返回第一个大于val的下标
3. binary_search(arr[],arr[]+size,val)找得到val返回真，否则返回假

69.Sqrt(x)
套模板，注意用long long。

class Solution {
public:
    long long mySqrt(long long x) {
        long long l=0,r=x;
        while(l<r){
            long long m=(l+r+1)>>1;
            if(m<=x/m) l=m;
            else r=m-1;
        }
        return l;
    }
};

35.Search Insert Position
注意比较比所有数字都小的情况。也可以写成找到>=的位置，那样判断的就是比所有数字都大的情况。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        if(nums.empty()||nums.front()>target) return 0;
        int l=0,r=nums.size()-1;
        while(l<r){
            int mid=(l+r+1)>>1;
            if(nums[mid]<=target) l=mid;
            else r=mid-1;
        }
        if(nums[l]<target) return l+1;
        else return l;
    }
};

34.Find First and Last Position of Element in Sorted Array
两个模板合用。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.empty()||target<nums.front()||target>nums.back()) return {-1,-1};
        int L,R;
        int l=0,r=nums.size()-1;
        while(l<r){
            int mid=(l+r+1)>>1;
            if(nums[mid]<=target) l=mid;
            else r=mid-1;
        }
        R=l;
        if(nums[R]!=target) return {-1,-1};
        l=0,r=nums.size()-1;
        while(l<r){
            int mid=(l+r)>>1;
            if(nums[mid]>=target) r=mid;
            else l=mid+1;
        }
        L=l;
        return {L,R};
    }
};

74.Search a 2D Matrix
两个二分，先定位横坐标，再定位纵坐标。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0) return false;
        int l=0,r=matrix.size()-1;
        
        while(l<r){
            int m=(l+r+1)>>1;
            if(matrix[m][0]<=target) l=m;
            else r=m-1;
        }
        int n=r;
        l=0,r=matrix[0].size()-1;
        while(l<r){
            int m=(l+r)>>1;
            if(matrix[n][m]>=target) r=m;
            else l=m+1;
        }
        if(matrix[n][r]==target) return true;
        else return false;
    }
};

153.Find Minimum in Rotated Sorted Array
假如左数大于右数，答案在此区间内。因为用到的是模板1，所以mid取下界，mid有可能和left相等，所以要比较的是mid和right。

class Solution {
public:
    int findMin(vector<int>& nums) {
        int l=0,r=nums.size()-1;
        while(l<r){
            int m=(l+r)>>1;
            if(nums[m]<nums[r]) r=m;
            else l=m+1;
        }
        return nums[l];
    }
};

33.Search in Rotated Sorted Array
找到最小数，分区间二分查找。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.size()==0) return -1;
        int l=0,r=nums.size()-1;
        while(l<r){
            int mid=(l+r)>>1;
            if(nums[mid]<nums[r]) r=mid;
            else l=mid+1;
        }
        int n=l;
        if(target<nums[0]){
            l=n,r=nums.size()-1;
        }else{
            l=0,r=n-1;
            if(n==0) r=nums.size()-1;
        }
        while(l<r){
            int mid=(l+r+1)>>1;
            if(nums[mid]<=target) l=mid;
            else r=mid-1;
        }
        if(nums[l]!=target) return -1;
        else return l;
    }
};

278.First Bad Version
也是挺模板的一道题。

// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        long long l=1,r=n;
        while(l<r){
            long long m=(l+r)>>1;
            if(isBadVersion(r)&&isBadVersion(m)) r=m;
            else l=m+1;
        }
        return l;
    }
};

162.Find Peak Element
寻找峰值，因为头尾等于负无穷，无论数列单调递增或单调递减都至少存在一个峰值。一个数的左边如果大于它，左边区间必须存在峰值，一个数的右边如果大于它，右边必须存在峰值。注意表示头尾负无穷时，不要让数组越界。

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int l=0,r=nums.size()-1;
        while(l<r){
            int m=(l+r)>>1;
            int t1,t2;
            if(m-1<0) t1=INT_MIN;else t1=nums[m-1];
            if(m+1>nums.size()-1) t2=INT_MIN;else t2=nums[m+1];
            if(t1<nums[m]&&t2<nums[m]){
                l=r=m;
            }
            else if(t1>nums[m]){
                r=m-1;
            }
            else if(t2>nums[m]){
                l=m+1;
            }
        }
        return l;
    }
};

287.Find the Duplicate Number
抽屉原理。值域在1~n，利用抽屉原理，假如放到抽屉l-m的苹果个数小于等于抽屉个数，重复数字一定出现在m+1-r那边。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int l=1,r=nums.size()-1;
        while(l<r){
            int mid=(l+r)>>1;
            int cnt=0;
            for(auto x:nums)
                if(x>=l&&x<=mid)
                    cnt++;
            if(cnt>mid-l+1)
                r=mid;
            else
                l=mid+1;
        }
        return l;
    }
};

275.H-Index II
值域在0-n，一开始纠结在误以为答案在数组中，但是，题意是h个数字大于等于h，而数组里面会有大于h的数字，因为升序，所以判断第size()-mid个数是否大于等于mid就好了。

class Solution {
public:
    int hIndex(vector<int>& nums) {
        int l=0,r=nums.size();
        while(l<r){
            int mid=(l+r+1)>>1;
            if(nums[nums.size()-mid]>=mid){
                l=mid;
            }else{
                r=mid-1;
            }
        }
        return l;
    }
};

最后两道题可以一起说一下，做了前面那么多题，后面才发现第一步，确定L,R是最关键的，因为最后两题不是直接在数组里面找答案，倒数第二题还好，但是最后一道题就很明显，确定值域很关键。