二分查找和二分查找的变形

最新推荐文章于 2025-06-12 14:36:08 发布

原创最新推荐文章于 2025-06-12 14:36:08 发布 · 281 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二分查找 #二分查找变形

稳定性/性能/功耗/算法等专栏收录该内容

16 篇文章

订阅专栏

//解法一：非递归版，最常见的一种二分查找算法
class Solution 
{
public:
    int search(vector<int>& nums, int target) 
    {
        int ret=-1;

        int begin=0;
        int end=nums.size()-1;

        while(begin<=end)
        {
            //int mid=(begin+end)/2; 为了防止整形溢出，所以采用下面的写法
            int mid=begin+(end-begin)/2;

            if(nums[mid]==target)
            {
                ret=mid;
                break;
            }
            else if(nums[mid]>target)
            {
                end=mid-1;
            }
            else
            {
                begin=mid+1;
            }
        }

        return ret;
    }
};

//解法二：递归版
class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        return search(nums,0,nums.size()-1,target);
    }

    int search(vector<int>& nums,int begin,int end,int target)
    {
        int ret=-1;
        
        if(begin<=end)
        {
            int mid=begin+(end-begin)/2;

            if(nums[mid]==target)
            {
                ret=mid;
            }
            else if(nums[mid]>target)
            {
                ret=search(nums,begin,mid-1,target);
            }
            else
            {
                ret=search(nums,mid+1,end,target);
            }
        }

        return ret;
    }
};

变形一：查找第一个值等于给定值的元素

template <typename T>
int binSearch(T array[],int len,T target)
{
    int ret=-1;

    int begin=0;
    int end=len-1;

    while(begin<=end)
    {
        int mid=begin+((end-begin)>>1);//提高效率，因为计算机处理移位操作，要比除法操作高效很多

        if(array[mid]>target)
        {
            end=mid-1;
        }
        else if(array[mid]<target)
        {
            begin=mid+1;
        }
        else
        {
            if(mid==0||array[mid-1]<target)
            {
                ret=mid;
                break;
            }
            else
            {
                end=mid-1;
            }
        }
    }

    return ret;
}

变体二：查找最后一个值等于给定值的元素

template <typename T>
int binSearch(T array[],int len,T target)
{
    int ret=-1;

    int begin=0;
    int end=len-1;

    while(begin<=end)
    {
        int mid=begin+((end-begin)>>1);//提高效率，因为计算机处理移位操作，要比除法操作高效很多

        if(array[mid]>target)
        {
            end=mid-1;
        }
        else if(array[mid]<target)
        {
            begin=mid+1;
        }
        else
        {
            if(mid==len-1||array[mid+1]>target)
            {
                ret=mid;
                break;
            }
            else
            {
                end=mid-1;
            }
        }
    }

    return ret;
}

变体三：查找第一个大于等于给定值的元素

template <typename T>
int binSearch(T array[],int len,T target)
{
    int ret=-1;

    int begin=0;
    int end=len-1;

    while(begin<=end)
    {
        int mid=begin+((end-begin)>>1);//提高效率，因为计算机处理移位操作，要比除法操作高效很多

        if(array[mid]>=target)
        {
            if(mid==0||array[mid-1]<target)
            {
                ret=mid;
                break;
            }
            else
            {
                end=mid-1;
            }
        }
        else
        {
            begin=mid+1;
        }
    }

    return ret;
}

变体四：查找最后一个小于等于给定值的元素

template <typename T>
int binSearch(T array[],int len,T target)
{
    int ret=-1;

    int begin=0;
    int end=len-1;

    while(begin<=end)
    {
        int mid=begin+((end-begin)>>1);//提高效率，因为计算机处理移位操作，要比除法操作高效很多

        if(array[mid]>target)
        {
            end=mid-1;
        }
        else
        {
            if(mid==len-1||array[mid+1]>target)
            {
                ret=mid;
                break;
            }
            else
            {
                begin=mid+1;
            }
        }
    }

    return ret;
}