C++算法之二分查找

二分查找

算法解释：二分查找也被称二分法或者折半查找，每次查找时通过将待查找区间分成两部分并只取一部分查找，将查找的复杂度大大减少，对于一个长度为O(n)的数组，二分查找的时间复杂度为O(logn)

1.求开方
给定一个非负整数，求他的开放你，向下取整

int mySqrt(int a)
{
    if(a==0) return a;
    int l=1,r=a,mid,sqrt;
    while(l<=r){
        mid=l+(r-1)/2;
        sqrt=a/mid;
        if(sqrt==mid){
            return mid;
        }
        else if(mid>sqrt){
            r=mid-1;
        }
        else{
            l=mid+1;
        }
    }return r;
}  

另外，更快的算法啊—牛顿迭代法

int mySqrt(int a)
{    
    long x=a;
    while (x*x>a){
        x=(x+a/x)/2;
    }
    return x;
}

2查找区间
给定一个增序的整数数组和一个值，查找该值第一次和最后一次出现的位置

//主函数
vector<int>searchRange(vector<int>&nums,int target){
    if(nums.empty()) return vector<int>{-1,-1};
    int lower=lower_bound(nums,target);
    int upper=upper_bound(num,target)-1;
    if(lower==nums.size()||nums[lower]!=target){
        return vector<int>{-1,-1};
    }
    return vector<int>{lower,upper};
}
//辅函数
int lower_bound(vector<int>&nums,int targets){
    int l=0,r=nums.size(),mid;
    while(l<r){
        mid=(l+r)/2;
        if (num[mid]>=target){
            r=mid;
        }
        else{
            l=mid+1;
        }
    }
    return l;
}

//辅函数
int upper_bound(vector<int>&nums,int targets){
    int l=0,r=nums.size(),mid;
    while(l<r){
        mid=(l+r)/2;
        if (num[mid]>=target){
            r=mid;
        }
        else{
            l=mid+1;
        }
    }
    return l;
}

3.旋转数组查找数字
一个原本增序的数组被首尾相连后按某个位置断开，我们称其为旋转数组。给定一个值，判断这个值是否存在于这个旋转数组中

bool search(vector<int>&nums,int target){
    int start=0,end=nums.size()-1;
    while(start<=end){
        int mid=(stard+end)/2;
        if(nums[mid]==target){
            return true;
        }
        if(nums[start]==nums[mid]){
        //无法判断哪个区间是增序的
            ++start;
        }
        else if(nums[mid]<=nums[end]){
        //右区间是增的
            if(target>nums[mid]&&target<=nums[end]){
                start=mid+1;
            }
            else{
                end=mid-1;
            }
        }
        else{
        //左区间是增序的
            if(target>=nums[start]&&target<num[mid]){
                end=mid-1;
            }
            else{
                start=mid+1;
            }
        }
    }
    return false;
}