二分查找的坑点与总结

最新推荐文章于 2022-10-18 12:19:24 发布
最新推荐文章于 2022-10-18 12:19:24 发布
阅读量252 收藏 1
点赞数
原文链接：https://blog.csdn.net/haolexiao/article/details/53541837
版权

以下是二分查找的标准写法
以下这个函数是二分查找nums中[left，right)部分，right值取不到，如果查到的话，返回所在地，如果查不到则返回最后一个小于target值得后一个位置。

//右值点不能取到的情况
    int binary_search(vector<int>& nums,int left,int right, int target) { 
    //坑点（1）right究竟能不能取到的问题，这里是不能取到的情况
        int i = left;
        int j= right;
        while(i<j){
            int mid = i+(j-i)/2;             //坑点（2）这里尽量这么写，因为如果写成(i+j)/2则有溢出的风险
            if(nums[mid]>=target)        //坑点（3）这个地方大于还是大于等于要依据情况而定
                j = mid;            //坑点（4）因为右值点反正不能取到，所以j就可以等于mid
            else
                i = mid+1;           //坑点（5）
        }
        return i;
    }

//右值点能取到的情况
    int searchInsert(vector<int>& nums,int left,int right, int target) {
        int i = left;
        int j= right;
        while(i<=j ){
            int mid = i+(j-i)/2;
            if(nums[mid]>=target)
                j = mid-1;
            else
                i = mid+1;
        }
        return i;
    }

一般来说写的二分查找的标准程序应该是右边right值取不到的情况，所以while循环中要加一步判断i是否小于等于nums.size();

A. 对于坑点2，如果是右值点可以取到情况下，必须是i<=j否则会出现查找偏差，比如数组中就一个元素[3]，让查找5的位置，理应返回1，但是此时会输出成0，
B. 对于坑点3，主要应用在如果数组中有重复元素，需要判断其具体要返回什么位置。
C. 对于坑点,5，如果i不加1的，比如i = 0，j= 1 的情况，会出现mid = 0然后一直死循环下去
D. 对于坑点4，依据right能不能取到而定，如果right可以取到则，right必须要-1，不减1的话，还是会出现i = j时的死循环。

另外一种二分查找，今天面试头条的时候，被要求写一个二分查找，原本以为足够的简单，但是发现坑点还是有很多的，比如面试官问，如果数组中出现了重复元素该怎么办？怎么返回重复元素的第一个位置，如果查不到则返回-1，后来想了想写了个这个方法

int searchInsert(vector<int>& nums, int target) {
    int i = 0;
    int j = nums.size() - 1;
    while (i < j) {
        int mid = i + (j - i) / 2;
        if (nums[mid] > target)
            j = mid - 1;
        else
            if (nums[mid] == target)      //即继续二分查找查找相等元素的左边界即可
                j = mid;
            else
                i = mid + 1;
    }
    if (nums[i] == target)
        return i;
    else
        return -1;
}

这个有一个简化的写法，减少比较次数【注意以下写法只适合返回最开始出现的位置，如果题目改成出现的最后的一个位置，则还是得用上面的方法】

int binarySearch(vector<int> &array, int target) {
       // write your code here
    int i = 0;
    int j = array.size() - 1;
    while (i < j) {
        int mid = i + (j - i) / 2;
        if (array[mid] >= target)
            j = mid ;
        else
            i = mid + 1;
    }
    if (array[i] == target)
        return i;
    else
        return -1;
 }

二分查找的变种

leetcode 153.Find Minimum in Rotated Sorted Array
就是一个排好序的数组，然后将其平移之后，找最小的元素。
诸如[3 4 5 6 7 1 2]

 int findMin(vector<int> &num) {
        int start=0,end=num.size()-1;

        while (start<end) {
            if (num[start]<num[end])
                return num[start];

            int mid = (start+end)/2;

            if (num[mid]>=num[start]) {  //这一步为什么要≥是因为如果mid = start的情况
                start = mid+1;
            } else {
                end = mid;
            }
        }

        return num[start];
    }

//更简洁的做法，比右边，因为最右边的必然严格小于最左边，所以等于上面的方法比了一个次小的
    int findMin(vector<int>& nums) {
        int i = 0, j = nums.size()-1;
        while(i<j){
            int mid = (i+j)/2;
            if(nums[mid]>nums[j])
                i =mid+1;
            else
                j = mid;
        }
        return nums[i];
    }
  1. Find Minimum in Rotated Sorted Array II
    它的进阶形式，如果有重复元素的话，该如何呢
    要考虑到这种情况[3 3 3 3 3 3 3 3 1 3 ] [1 1 1 1 1 1 1 1 1 1 2 1 1]
    int findMin(vector<int>& nums) {
        int i = 0, j = nums.size()-1;
        while(i<j){
            int mid = (i+j)/2;
            if(nums[mid]>nums[j])
                i =mid+1;
            else
                if(nums[mid]<nums[j])
                    j = mid;
                else
                    j--;
        }
        return nums[i];
    }
  //但实际上这种方法是有一点小问题的，虽然在这个问题中体现不出来，比如就是如果最小值是重复的，且最小值横跨数组左右两个端点的时候，诸如[1 1 1 1 1 1 1 1 1 1 2 1 1]这种情况，它找出的最小值的位置其实严格意义上不算最小值的位置。     [*]
  1. Search in Rotated Sorted Array
    就是在平移数组中找到一个目标数target，找不到则返回-1，找到返回下标
//这道题一开始的思路是直接二分，然后，后来看了解答，就是用上面的方法找出最小值，然后最小值的位置也就意味着其右平移的距离，所以先假设数组没有平移，二分查找，mid的位置给换成现在数组的位置 rot_mid = (mid+rotate)%n
    int search(vector<int>& nums, int target) {
        int i=0,j= nums.size()-1;
        while(i<j){
            int mid = (i+j)/2;
            if( nums[mid]>nums[j])
                i = mid+1;
            else
                j = mid;
        }
        int rot = i;
        i = 0;
        j = nums.size()-1;
        while(i<=j){   //注意这个地方必须是<=，因为[1] 找1，如果是<的话就不行了。
            int mid = (i+j)/2;
            int rot_mid = (mid+rot)%nums.size();
            if(nums[rot_mid] == target) return rot_mid;
            if(nums[rot_mid]>target)
                j = mid-1;
            else
                i = mid+1;
        }
        return -1;
    }

进阶形式，就是数组中有重复元素了怎么办
81. Search in Rotated Sorted Array II

    bool search(vector<int>& nums, int target) {
        int i = 0,j = nums.size()-1;
        while(i<j){
            int mid = (i+j)/2;
            if(nums[mid]>nums[j])
                i = mid+1;
            else
                if(nums[mid]<nums[j])
                    j = mid;
                else
                    j--;
        }
//鉴于[*]处的分析，所以这种最小值是重复的，且横跨首尾的情况，需要额外处理
        if(i == 0 && nums[i] == nums[nums.size()-1]){
            i = nums.size()-1;
            while(i>0 &&nums[i-1] == nums[i]) i--;
        }

        int rot = i;
        i = 0;
        j = nums.size()-1;
        while(i<=j){
            int mid = (i+j)/2;
            int rot_mid = (mid+rot)%nums.size();
            if(nums[rot_mid] == target) return true;
            if(nums[rot_mid]>target)
                j = mid-1;
            else
                i = mid+1;
        }
        return false;
    }

或者采用我一开始的直接二分判断的方法

    bool search(vector<int>& nums, int target) {
        int i = 0,j = nums.size()-1;
        while(i<=j){
            int mid = (i+j)/2;
            if(nums[mid] == target)
                return true;
            if(nums[mid]>nums[j])
                if(target>nums[mid] ||target<=nums[j])
                    i = mid+1;
                else
                    j = mid-1;
            else
                if(nums[mid]<nums[j])
                    if(target>nums[mid] && target<=nums[j])
                        i = mid+1;
                    else
                        j = mid-1;
                else
                    j--;
        }
        return false;
    }

除此之外，还可参考这个博客：如何写出正确的二分查找？——利用循环不变式理解二分查找及其变体的正确性以及构造方式

sdf57
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【LeetCode】·【704. 二分查找】·【不成功】
satlin003的博客
11-17 453
如果二分的时候，新的下标值不是目标值，下标和旧下标又不差1，也就是说如果他二分发现，太小了，我得回去，那我这时候根本就没有二分，而是此时到之前的所有元素二分。如果值等于 直接返回下标，如果值大于，则下标除2，如果值小于，则搞一个下标在后面一半数组的中间。答案用左右两个下标，来缩短范围，也就是先二分，如果值小于，就把范围缩到这个下标，大于就把范围缩到这个下标。这里就感受到了，我需要不新建数组，却要达到记录二分的范围，而且还得让每次计算后的结果，都是二分，缩小查询范围。于是开始实现，一开始的代码是这样的。
二分查找(Binary Search) 常见问题解决方法总结
热门推荐
Daniel 的技术笔记 不积跬步无以至千里，不积小流无以成江海。
12-13 1万+
缘由今天浏览 何登成的技术博客  无意中发现了写的blog，二分查找(Binary Search)需要注意的问题，以及在数据库内核中的实现。随想总结下二分查找的常见问题。问题背景今年的实习生招聘考试，我出了一道二分查找(Binary Search)的题目。题目大意如下：给定一个升序排列的自然数数组，数组中包含重复数字，例如：[1,2,2,3,4,4,4,5,6,7,7]。问题：给定任意自然数，对数...
二分查找法
weixin_45960743的博客
07-13 147
前提 数组是有序的（如果无序，我们也可以考虑排序，不过要注意排序的复杂度 ） 术语 二分查找中使用的术语： target —— 要查找的值 index —— 当前位置 l 和 r —— 左右指针 mid —— 左右指针的中点，用来确定我们应该向左查找还是向右查找的索引 思维框架 首先定义搜索区间为 [left, right]，注意是左右都闭合，之后会用到这个点 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜索区间。 由于定义的搜索区间为 [left, right]，
二分查找指定的数，总是”找不到“，解决办法
m0_46811353的博客
02-11 661
#include<stdio.h> int binary_search(int arr[], int k) { int sz = sizeof(arr) / sizeof(arr[0]);//求数组长度 int left = 0;//定义左下标 int right = sz - 1;//定义右下标 while (left <= right) //使用while循环判断左是否小于等于右下标，若是则进入循环，循环完之后，若找到下标，则返回此下标，还是找不到条件，则返回-1 {
算法--分治 二分检索
人总是要有梦想的QAQ的博客
03-08 176
二分检索
二分查找算法PPT课件
04-11
二分查找算法，二分查找算法课件，二分查找算法PPT
C语言快速排序与二分查找算法示例
08-28
主要介绍了C语言快速排序与二分查找算法,涉及C语言随机数生成、快速排序及二分查找等算法相关实现技巧,需要的朋友可以参考下
js实现的二分查找算法实例
10-22
主要介绍了js实现的二分查找算法,结合实例形式较为详细的分析了JavaScript简单实现二分查找算法的运算原理与具体步骤,需要的朋友可以参考下
简介二分查找算法与相关的Python实现示例
09-21
主要介绍了二分查找算法与相关的Python实现示例,Binary Search同时也是算法学习当中最基础的知识,需要的朋友可以参考下
二分查找算法代码+二分查找算法思想
最新发布
05-13
二分算法，也称为二分查找或折半查找，是一种在有序数据集中查找特定元素的算法。其基本思想是： 起始时，将数据集视为一个区间，区间包含所有待搜索的元素。 计算区间的中间元素，并将待查找的元素与中间元素进行...
二分查找如果查找失败，则查找次数为多少
weixin_62549963的博客
10-18 815
二分查找如果查找失败，则查找次数为多少
二分查找算法及其变种详解
Abysscarry的博客
02-15 5779
背景： 春节已过，开工大吉！让我们回顾下一些经典的算法吧 ~ 一、思想介绍 二分查找（Binary Search）算法，也叫折半查找算法，它的思想非常简单，在生活中随处可见（比如：猜字游戏），但这看似简单的算法，实际却没那么容易掌握透彻。 二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被...
leetcode 35. 搜索插入位置(二分法搜索失败的情况)
暮色年华的博客
12-13 631
35. 搜索插入位置 思路：二分查找 模板： 如果查找成功，返回target在nums中的下标 //二分查找模板 //nums[0..n-1]为有序数组,target为目标 int left=0; int right=n-1; while(left<=right) { if(nums[mid]==target) { return mid; } else if(nums[mid]>target) { right=mid-1; } .
二分查找总结
zhourunan
09-02 4034
1.二分查找又称折半查找 2.优点：比较次数少;查找速度快;平均性能好 3.缺点：待查表为有序数组（若为无序数组，分成两份查找无意义，排序本身也耗费时间）;插入删除困难（增删需要移动大量的节点） 4.思想： 在一个有序数组中，取数组的中间值与要查找的数进行比较； 若要查找的数等于中间值，查找成功； 若要查找的数大于中间值，则在右半区间继续取中间值与要查找的数进行比较； 若要查找的数小...
二分查找爬过的坑
seeker的博客
08-30 962
二分查找看似简单，但是刷多了二分查找的题，就会遇到很多意向不到的坑，真的是实践出真知啊，现总结下二分查找遇到的坑。 一 朴素版二分查找：在有序数组中查找关键字，找到就返回下标，不管重复不重复。//朴素版二分查找 int bitsearch(int A[],int n,int k){ int l=0,r=n-1; int mid; while(l <= r){ //为什么不是 l
二分查找 查不到怎么办！
weixin_30478923的博客
07-21 257
引自：http://blog.csdn.net/int64ago/article/details/7425727int64Ago 　　看到这个标题无论你是处于怎样的心理进来看了，我觉得都是值得的。因为这个问题太简单，任何一个开始接触“真正”算法基本都是从二分查找开始的。至于二分查找都不知道是什么的可以先去找别的资料看下，再来看这篇文章。既然很简单，那么我们开始一起写一个吧，要求是对...
二分查找法（容易被忽略的错误）
qq_37065641的博客
05-17 1219
  使用二分查找,必须要满足： 存储在数组中(不可以是链表)、有序排列 public class BinarySearch{ public static int BinarySearch(int [] list , int key ){ int low = 0，high = list.length -1; while( low &lt;= h...
二分答案与二分查找的区别
04-11
二分答案和二分查找是两个不同的概念。 1. 二分答案（Binary Search for Answer）是一种解决某些特定问题的算法思想。它通常用于在一个有序的数值范围内寻找满足某个条件的最优解或特定目标的值。二分答案的基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值