二分查找详解-(退出循环时,left与right的含义)

comAndny

已于 2022-09-02 13:22:01 修改

阅读量1.2k

点赞数 2

文章标签：算法 leetcode 数据结构

于 2022-09-02 13:20:07 首次发布

本文链接：https://blog.csdn.net/qq_45802809/article/details/126660766

版权

二分查找

704二分查找

方法一

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] （这个很重要非常重要）。

区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点：

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        int middle = 0 ;
        while(left <= right){  // middle的定义于[left,right] => [0,nums.length-1]
             // middle = (right - left + 2 * left)/2  
            middle = (right  - left)/2 + left;
            if(nums[middle] == target){
                return middle;
            }else if(nums[middle] > target){
                right = middle -1; // 范围在[left,middle-1]
            }else if(nums[middle] < target){
                left = middle + 1; // 范围在[middle + 1,right]
            }
        }

        return -1;
    }
}

方法二

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。

有如下两点：

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length;
        int middle = 0 ;
        while(left < right){ // middle的定义于[left,right) => [0,nums.length)
            // middle = (right - left + 2 * left)/2  
            middle = (right  - left)/2 + left;
            if(nums[middle] == target){
                return middle;
            }else if(nums[middle] > target){
                right = middle ; // 范围在[left,middle)
            }else if(nums[middle] < target){
                left = middle + 1 ; // 范围在[middle,right)
            }
        }
        return -1;
    }
}

35.搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4

题解

思考，当退出while时，left与right值的意义

结论：left表示比target小的在数组中元素的个数,比如当left = 4 ，表示数组中有前4个元素小于target

例如：[1,2,3,5] target=4, left在退出循环后为3，表示前3个元素[1,2,3]小于target

这个结论适用于 left与right 在 [0,nums.length-1] 和 [0,nums.length)时的情景，所以方法一与方法二都可以这样使用。

退出以后left的取值范围在[0,nums.length]

参考：https://blog.csdn.net/xushiyu1996818/article/details/102482609

方法一

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        int middle = 0 ;
        while(left <= right){  // middle的定义于[left,right] => [0,nums.length-1]
             // middle = (right - left + 2 * left)/2  
            middle = (right  - left)/2 + left;
            if(nums[middle] == target){
                return middle;
            }else if(nums[middle] > target){
                right = middle -1; // 范围在[left,middle-1]
            }else if(nums[middle] < target){
                left = middle + 1; // 范围在[middle + 1,right]
            }
        }
		// 表示target前有left的元素，那么插入后，target在数组中的坐标就是left
        return left;
    }
}

方法二

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length;
        int middle = 0 ;
        while(left < right){ // middle的定义于[left,right) => [0,nums.length)
            // middle = (right - left + 2 * left)/2  
            middle = (right  - left)/2 + left;
            if(nums[middle] == target){
                return middle;
            }else if(nums[middle] > target){
                right = middle ; // 范围在[left,middle)
            }else if(nums[middle] < target){
                left = middle + 1 ; // 范围在[middle,right)
            }
        }
        // 表示target前有left的元素，那么插入后，target在数组中的坐标就是left
        return left;
    }
}

34.在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
    
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
    
示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums.length == 0) {
            return new int[]{-1, -1};
        }
        // 默认情况下都为-1
        int[] res = {-1, -1};

        int left = 0;
        int right = nums.length - 1;
        // 寻找左边界
        while (left <= right) {
            int mid = (right - left) / 2 + left;
            if (nums[mid] == target) {  // 可能会遇到在[left,mid-1)中 不存在target的情况,
                // 不过没关系 因为这种情况是原来情况(搜索插入位置中的情况), 
                // 如果写成right = mid , 会造成left = right
                // 且 nums[mid] = target 的情况，,而造成死循环
                right = mid - 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        // 退出时left 可能等于nums.length, 此时不存在左边界,因为target不在nums中
        // 本题目的要求是target要存在nums中,所以要判断 nums[left] == target
        // 如果为true，则表示存在,left 就是他的左边界
        // 如果是false,表示不出在
        if (left < nums.length && nums[left] == target) {
            res[0] = left;
        }

        left = 0;
        right = nums.length - 1;

        // 寻找右边界
        while (left <= right) {
            int mid = (right - left) / 2 + left;
            if (nums[mid] == target) {
                // 这里同样不能写 left = mid,会找成死循环, 此时的区间为[mid+1,right]
                // 如果target的右边界为mid, 那么它将在[mid+1,right]之外
                // 不过没关系,[mid+1,right] 会在后续中,向mid收缩,
                // 因为在mid在[mid+1,right]的右边 
                // 会收缩到[mid+1,mid+1], 再收缩 =>  [mid+1,mid] 退出循环
                // 所以如果target在nums中,则左边界-1(或者是右边界的值) 就是它的最右区间
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        // 这里同样判断
        if (left - 1 >= 0 && nums[left - 1] == target) {
            res[1] = left - 1;
        }
        return res;
    }
}

69.x的平方根(练习)

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：
输入：x = 4  
输出：2
    
示例 2：
输入：x = 8
输出：2   
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

在这里插入图片描述

现在要插入一个数x，假设它满足m的平方<x<(m+1)的平方 ,不用考虑相等，因为那会直接返回

退出循环后，left的值为m+1

表示前面有m+1个数小于它

这里题目要求向下取整，所以返回left-1 也就是m

如果是向上取整，则返回left，也就是m+1

class Solution {
    public int mySqrt(int x) {
        int left= 0;
        int right =x;
        while(left <=right ){ // mid的取值为[left,right]
            int mid = (right - left)/2 +left;
            long val =(long) mid * mid;
            if(val == x){
                return mid;
            }else if (val > x){
                right = mid -1;
            }else if(val < x){
                left = mid +1;
            }
        }
        return left-1;
    }
}

367.有效的完全平方数(练习)

给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

进阶：不要 使用任何内置的库函数，如  sqrt 。

示例 1：
输入：num = 16
输出：true
    
示例 2：
输入：num = 14
输出：false

class Solution {
    public boolean isPerfectSquare(int num) {
        int left = 0;
        int right = num/2+1;
        while(left <= right){
            int mid = (right - left)/2 + left;
            long val =(long) mid * mid;
            if(val == num){
                return true;
            }else if(val > num){
                right = mid - 1;
            }else if(val < num){
                left = mid + 1;
            }
        }

        return false;
    }
}