基本查找算法——二分查找总结

最新推荐文章于 2023-05-31 11:21:12 发布

Small_Fish25

最新推荐文章于 2023-05-31 11:21:12 发布

阅读量658

点赞数 1

分类专栏：数据结构与算法专题文章标签：算法

本文链接：https://blog.csdn.net/qq_42642142/article/details/115015262

版权

数据结构与算法专题专栏收录该内容

21 篇文章 2 订阅

订阅专栏

二分查找

二分查找是一种非常简单易懂的快速查找算法，时间复杂度为O(logn)，这是相当快的了。利用二分思想，即便猜一个 0 到 999 的数字，最多也只要 10 次就能猜中。

基本形式代码：

//在有序不重复元素中寻找指定值的位置，不存在返回-1
int bsearch(vector<int> & nums,int val){
    int n = nums.size();
    int left = 0;
    int right = n - 1;
    while (left<= right)
    {
        int mid = left + ((right - left) >> 1);
        if (nums[mid] == val){
            return mid;
        }else if(nums[mid] < val){
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return -1;
}

注意方面：

循环退出条件：

注意是 left<=right，而不是 left < right
mid 的取值：

实际上，mid=(left +right)/2 这种写法是有问题的。因为如果 left和 right比较大的话，两者之和就有可能会溢出。改进的方法是将 mid 的计算方式写成 left+(right-low)/2。更进一步，如果要将性能优化到极致的话，我们可以将这里的除以 2 操作转化成位运算 left+((right-left)>>1)。因为相比除法运算来说，计算机处理位运算要快得多。注意：小心运算符优先级大小，不要写成 left+(right- left) >> 1
left和 right的更新：

left=mid+1，right=mid-1。注意这里的 +1 和 -1，如果直接写成 left=mid 或者 right=mid，就可能会发生死循环。比如，当 right=3，left=3 时，如果 nums[3]不等于 value，就会导致一直循环不退出。

二分查找转递归形式：

//递归形式的二分查找
int bsearchInternally(vector<int> &nums,int left,int right,int val){
    if (left > right){
        return -1;
    }
    int mid = left + ((right- left)>>1);
    if (nums[mid] == val){
        return mid;
    }else if (nums[mid] < val){
        return bsearchInternally(nums,mid + 1,right,val);
    }else{
        return bsearchInternally(nums,left,right - 1,val); 
    }
}

二分查找的局限性：

二分查找依赖的是顺序表结构(数组)

主要原因是二分查找算法需要按照下标随机访问元素。数组按照下标随机访问数据的时间复杂度是 O(1)，而链表随机访问的时间复杂度是 O(n)。所以，如果数据使用链表存储，二分查找的时间复杂就会变得很高。
二分查找针对的是有序数据

二分查找对这一点的要求比较苛刻，数据必须是有序的。如果数据没有序，我们需要先排序。前面章节里我们讲到，排序的时间复杂度最低是 O(nlogn)。所以，如果我们针对的是一组静态的数据，没有频繁地插入、删除，我们可以进行一次排序，多次二分查找。这样排序的成本可被均摊，二分查找的边际成本就会比较低。
数据量太小不适合二分查找

要处理的数据量很小，完全没有必要用二分查找，顺序遍历就足够了。比如我们在一个大小为 10 的数组中查找一个元素，不管用二分查找还是顺序遍历，查找速度都差不多。只有数据量比较大的时候，二分查找的优势才会比较明显。
数据量太大也不适合二分查找

二分查找的底层需要依赖数组这种数据结构，而数组为了支持随机访问的特性，要求内存空间连续，对内存的要求比较苛刻。比如，我们有 1GB 大小的数据，如果希望用数组来存储，那就需要 1GB 的连续内存空间。

4种常见二分查找的变形问题

有时候我们需要查找的并不是一个有序无重复数组种的某个值，而是在一个有序有重复数组种查找位于最前面的某个值等等…因此，就出现了常见的4种变形问题：

查找第一个值等于给定值的元素
查找最后一个值等于给定值的元素
查找第一个大于等于给定值的元素
查找最后一个小于等于给定值的元素

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

其实这只是对基本二分查找的变形，但是不注意也会有很多错误，下面贴上代码：

//**查找第一个值等于给定值的元素**
int bsearchFirst(vector<int> & nums,int val){
    int n = nums.size();    
    int left = 0;
    int right = n - 1;
    while (left <= right)
    {
        int mid = left + ((right - left)>>1);
        if (nums[mid] < val){
            left = mid + 1;
        }else if (nums[mid] > val){
            right = mid - 1;
        }else {
            if (mid == 0 || nums[mid - 1] != val)
                return mid;
            else
                right = mid - 1;
        }
    }
    return -1;
}

如果我们查找的是任意一个值等于给定值的元素，当 nums[mid]等于要查找的值时，nums[mid]就是我们要找的元素。但是，如果我们求解的是第一个值等于给定值的元素，当 nums[mid]等于要查找的值时，我们就需要确认一下这个 nums[mid]是不是第一个值等于给定值的元素。

我们重点看if (mid == 0 || nums[mid - 1] != val)行代码。如果 mid 等于 0，那这个元素已经是数组的第一个元素，那它肯定是我们要找的；如果 mid 不等于 0，但 nums[mid]的前一个元素 nums[mid-1]不等于 value，那也说明 nums[mid]就是我们要找的第一个值等于给定值的元素。

如果经过检查之后发现 nums[mid]前面的一个元素 nums[mid-1]也等于 value，那说明此时的 nums[mid]肯定不是我们要查找的第一个值等于给定值的元素。那我们就更新 high=mid-1，因为要找的元素肯定出现在[low, mid-1]之间。

查找最后一个值等于给定值的元素

同样的，查找最后一个值等于给定值的元素也和上述思路相同。

//**查找最后一个值等于给定值的元素**
int bsearchLast(vector<int> & nums,int val){
    int n = nums.size();
    int left = 0;
    int right = n - 1;
    while (left <= right)
    {
        int mid = left+((right - left) >> 1);
        if (nums[mid] < val){
            left = mid + 1;
        }else if (nums[mid] > val){
            right = mid - 1;
        }else{
            if (mid == n - 1 || nums[mid + 1] != val){
                return mid;
            }else{
                left = mid + 1;
            }
        }
    }
    return -1;
}

查找第一个大于等于给定值的元素

//**查找第一个大于等于给定值的元素**
int bsearchOverFirst(vector<int> &nums,int val){
    int n = nums.size();
    int left = 0;
    int right = n - 1;
    while (left <= right){
        int mid = left + ((right - left)>>1);
        if (nums[mid] >= val){
            if (mid == 0 || (nums[mid - 1] < val)){
                return mid;    
            }
            right = mid - 1;
        }else{
            left = mid + 1;
        }
    }
    return -1;
}

查找最后一个小于等于给定值的元素

//**查找最后一个小于等于给定值的元素**
int bsearchOverLast(vector<int> & nums,int val){
    int n = nums.size();
    int left = 0;
    int right = n - 1;
    while (left <= right){
        int mid = left + ((right - left)>>1);
        if (nums[mid] <= val){
            if (mid == n-1 || nums[mid + 1] > val){
                return mid;
            }
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return -1;
}

相关练习题

如何编程实现“求一个数的平方根”？要求精确到小数点后 6 位。

#define ACCURACY 1e-7
bool equal(double a,double b){
    //浮点数比较不能直接等于，要用一个精度的范围来判定
    return (a - b) > -ACCURACY && (a - b) < ACCURACY;
}

double Mysqrt(double val){
    double left = 0;
    double right = val;
    while (!equal(left,right))
    {
        double mid = left + (right - left) / 2;
        if (mid * mid > val)
        {
            right = mid;
        }else{
            left = mid;
        }
    }
    return left;
}

测试cout<<Mysqrt(10);

输出：3.16228

windows自带计算器计算结果: 3.162277660168379

如果有序数组是一个循环有序数组，比如 4，5，6，1，2，3。针对这种情况，如何实现一个求“值等于给定值”的二分查找算法呢？

我们可以在常规二分查找的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid] 和 [mid + 1, r] 哪个部分是有序的，并根据有序的那个部分确定我们该如何改变二分查找的上下界，因为我们能够根据有序的那部分判断出 target 在不在这个部分：

如果 [l, mid - 1] 是有序数组，且 target 的大小满足[nums[l],nums[mid])，则我们应该将搜索范围缩小至 [l, mid - 1]，否则在 [mid + 1, r] 中寻找。
如果[mid, r] 是有序数组，且 target 的大小满足(nums[mid+1],nums[r]]，则我们应该将搜索范围缩小至 [mid + 1, r]，否则在[l, mid - 1]中寻找。

在这里插入图片描述

    int search(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0;
        int right = n-1;
        if (n == 0){
            return -1;
        }
        if (n == 1){
            return nums[0] == target ? 0 : -1;
        }
        while (left <= right)
        {
            //划分左、右半边
            int mid = left +((right - left)>>1);
            //如果中间值为target直接返回下标
            if (nums[mid] == target){
                return mid;
            }
            if (nums[0] <= nums[mid]){//左半边是升序
                if (target >= nums[left] && target < nums[mid]){//目标值在左半边
                    right = mid - 1;//在左边继续查找
                }else{
                    left = mid + 1;//在右边继续查找
                }
            }else{//右半边是升序
                if(target > nums[mid] && target <= nums[right]){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }
        }
        return -1;
    }

Small_Fish25

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
基本查找算法——二分查找总结

二分查找二分查找是一种非常简单易懂的快速查找算法，时间复杂度为O(logn)，这是相当快的了。利用二分思想，即便猜一个 0 到 999 的数字，最多也只要 10 次就能猜中。基本形式代码：//在有序不重复元素中寻找指定值的位置，不存在返回-1int bsearch(vector<int> & nums,int val){ int n = nums.size(); int left = 0; int right = n - 1; while (lef
复制链接

扫一扫