阅读 52

关于二分查找的一些思考

最近在做二分查找的算法,发现二分查找并不是想象的那么简单,尤其是终止条件,已经mid的取值问题,总是让我晕头转向,下面以一个例子,说一下我对二分查找的理解归纳:

leetcode:剑指 Offer 53 - I. 在排序数组中查找数字 I

统计一个数字在排序数组中出现的次数。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
复制代码

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
复制代码

限制:

0 <= 数组长度 <= 50000
复制代码

来源:力扣(LeetCode) 链接:leetcode-cn.com/problems/za… 著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

相信大家都已经理解了这个题目的意思:下面我说一下我当时做这个题目的思路

思路一

通过二分查找,找到target的索引index,然后从index左右扩展统计个数,代码如下:

public int search(int[] nums, int target) {
        int index = getIndex(nums,target);
        if(index < 0){
            return 0;
        }
        int count = 1;
        // 左侧可能还有
        for(int i = index-1 ; i >= 0; i--){
            if(nums[i] != target){
                break;
            }
            count++;
        }
        // 右侧可能也还有
        for(int i = index+1; i < nums.length; i++){
            if(nums[i] != target){
                break;
            }
            count++;
        }
        return count;
    }

    public int getIndex(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (right - left) / 2 + left;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] > target){
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }
        return -1;
    }
复制代码

执行结果:

执行结果:通过
执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗:41.5 MB, 在所有 Java 提交中击败了27.56%的用户
复制代码

当然这里我们不讨论执行效率,内存消耗情况,我们只是为了归纳出二分查找的一些常常让我们模糊的地方。这里我们主要讨论getIndex方法:这个方法可以归纳为一句话:从数组中找目标,找到返回index,找不到返回-1

数组寻值

问题(1):什么时候代码终止?

我们定义left=0,right=length-1,所以我们的查找范围是[left, right],闭区间,如果我们设置为 left < right 那么终止条件就是 left == right, 此时 [right, right], 恰好漏掉了一个 int[right]或者 int[left],如果我们设置为 left <= right, 那么终止条件就是 left == right+1,此时 [right+1, right] 范围为空

问题(2)int mid = (right - left) / 2 + left,为什么不直接 mid = (right+left)/2 ?

主要是考虑整型溢出的问题,这里我们不重点讨论(也没有讨论的必要,哈哈)。

问题(3)right为什么是mid - 1, left 为什么是 mid + 1 ?

主要是因为我们的范围是闭区间,而且我们已经知道了mid不符合条件;

思路二

找到左右index的位置,然后count = rightIndex - leftIndex - 1; 比如 ums = [5,7,7,8,8,10], target = 8, 4-3+1= 2

public int search(int[] nums, int target) {
        if(nums.length == 0){
            return 0;
        }
        int left = 0;
        int right = nums.length;
        // 寻找左侧边界
        while(left < right){
            int mid = left + (right-left)/2;
            if(nums[mid] == target){
                right = mid;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                right = mid;
            }
        }
        int leftindex = left;

        left = 0;
        right = nums.length;
        // 寻找右侧边界
        while(left < right){
            int mid = left + (right-left)/2;
            if(nums[mid] == target){
                left = mid + 1;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                right = mid;
            }
        }
        int rightindex = right - 1;

        int count = rightindex - leftindex + 1;
        return count;
        
    }
复制代码

执行结果:

执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗:41.1 MB, 在所有 Java 提交中击败了90.76%的用户
复制代码

寻找左侧边界:

问题一:为什么这里的结束条件是 left < right

这里主要是因为 left=0, right=length, [left,right) 是一个左闭右开的区间,left == right是结束的条件,如果是 left <= right,那么结束的条件是 left == right+1, left可以取到right, right+1 造成数组下标越界, 这也是为什么right=mid 和 left=mid+1的原因

问题二:为什么最后左边界是left

因为最后退出是left==right,这是结束的条件,此时nums[mid]=target,所以最后返回left和right是一样的

寻找右侧边界

关于退出条件是同样的一个道理,最后为什么返回的是right-1,是因为最后退出的条件是left == right,而此时nums[mid] == target,而left == mid + 1,所以mid == left - 1也就是right -1;

总结

在写二分查找的时候,我们应该先理解区间的开闭,然后根据开闭确定退出条件,当然无论是左开右闭还是左闭右开,我们都可以替换为双闭区间,最后的返回数据要和mid的关系去对应起来,这样面对二分查找,我们再也不会为退出条件和返回参数而惆怅了。

文章分类
代码人生
文章标签