二分查找 个人详解 力扣#34 #74 #33 #81

int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;

    while(...) {
        int mid = (right + left) / 2;
        if (nums[mid] == target) {
            ...
        } else if (nums[mid] < target) {
            left = ...
        } else if (nums[mid] > target) {
            right = ...
        }
    }
    return ...;
}

首先是二分查找的框架 其中...的是需要判断的地方

 

基础情况一：

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1; // 注意

    while(left <= right) { // 注意
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1; // 注意
        else if (nums[mid] > target)
            right = mid - 1; // 注意
        }
    return -1;
}

首先 为什么while循环中的...是left <= right呢

题目中的right 是num.length - 1 等价于[left, right]

如果right 为num.length呢 则等价于[left, right) => 数组越界啦

 

left <= right 等价于[right + 1, right] 找个数带入进去也就是[3, 2]

如果是left < right 则等价于[right, right] 也就是[2, 2]

这种情况很可能在[1, 2]的时候更新了搜索区间 直接return -1跳出了

而mid = 2的情况还没来得及搜索 从而产生错误

 

来一个进阶的题目 其实就是昨天发的力扣#34

里面有两个延伸情况 一个是查找左侧区间 一个是查找右侧区间

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        int[] res = {-1, -1};
        while(left <= right){
            //搜索区间[left, right]都可以取到
            int mid = (left + right) / 2;
            //为什么left 和 right 更新之后都是mid +- 1呢
            //因为判断条件是mid 也就是说mid已经被判断过了
            //所以我们可以直接进入mid周围的下一个区间继续判断
            if(nums[mid] < target){
                left = mid + 1;
            //这里是寻找左区间 退出的条件是[left, left - 1] 可自行理解
            }else if(nums[mid] > target){
                right = mid - 1;
            }else{
                right = mid - 1;
            }
        }
        if(left == nums.length || nums[left] != target){
            return res;
        }else{
            res[0] = left;
        }
        //第二次扫描
        left = 0;
        right = nums.length - 1;
        while(left <= right){
            int mid = (left + right) / 2;
            //这里同上 不过退出的条件是[right + 1, right]
            if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        res[1] = right;
        return res;
    }
}

再来个进阶题目咯 力扣#74 要注意两个特殊判断

第一次对二维矩阵的第一列进行二分查找 要注意理解为什么搜索完第一列后

返回的是binarySearch(matrix[left - 1], target);

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int left = 0, right = matrix.length - 1;
        if(matrix.length == 0) return false;
        if(matrix[0].length == 0) return false;
        while(left <= right){
            int mid = (left + right) / 2;
            if(matrix[mid][0] == target){
                return true;
            }else if(matrix[mid][0] < target){
                left = mid + 1;
            }else if(matrix[mid][0] > target){
                right = mid - 1;
            }
        }
        if(left - 1 <= 0) return binarySearch(matrix[0], target);
        return binarySearch(matrix[left - 1], target);
    }

    public boolean binarySearch(int[] matrix, int target){
        int left = 0, right = matrix.length - 1;
        while(left <= right){
            int mid = (left + right) / 2;
            if(matrix[mid] == target){
                return true;
            }else if(matrix[mid] < target){
                left = mid + 1;
            }else if(matrix[mid] > target){
                right = mid - 1;
            }
        }
        return false;
    }
}

力扣 #33和他的后续 #81 主要是旋转排序数组 可以通过mid 和 left判断 target在哪个区间 然后确定下一步的二分查找 比如 [ 4 5 6 7 1 2 3]  从 7 劈开 左边是 [ 4 5 6 7] 右边是 [ 7 1 2 3] 左边是有序的

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while(left <= right){
            int mid = (left + right) / 2;
            if(target == nums[mid]){
                return mid;
            }
            if(nums[left] <= nums[mid]){ //左半段是有序的
                if(target >= nums[left] && target < nums[mid]){//target在这一段里
                    right = mid - 1;
                }else{//target在另一段里
                    left = mid + 1;
                }
            }else{//右半段是有序的 下面同理
                if(target <= nums[right] && target > nums[mid]){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }
        }
        return -1;
    }
}

这一题多了个特例 因为允许出现重复数字 当nums[left] == nums[mid]的时候 例如nums = [ 1, 3, 1, 1, 1 ]  target = 3 就会返回false 因为我们默认是认为左半段有序 但由于重复数字出现

nums[start] = 1 nums[mid] = 1 此时左半部分[1, 3, 1]并不是有序的 所以要单独考虑 nums[start] == nums[mid]的情况

class Solution {
    public boolean search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while(left <= right){
            int mid = left + (right - left) /2;
            if(nums[mid] == target){
                return true;
            }
            if(nums[left] < nums[mid]){
                if(target >= nums[left] && target < nums[mid]){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }else if(nums[left] == nums[mid]){
                left++;
            }else{
                if(target > nums[mid] && target <= nums[right]){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }
        }
        return false;
    }
}