二分查找算法的题解集合

leetcode704.基本的二分查找

题目：https://leetcode.cn/problems/binary-search/

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例：

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

解法：

//基本的二分查找（考虑：边界问题）
public static int search_basic(int[] nums, int target){
    int left = 0 , right = nums.length;  // 注意点1
    int mid = -1;
    while(left < right){  // 注意点2
        // 与 (left + right) / 2 得到的结果一致。
        // 下面这种写法可以一定程度避免 left + right 导致 int类型超过最大值。
        mid = left + (right - left) / 2;
        if(nums[mid] == target){
            return mid;
        }else if (nums[mid] < target){
            left = mid + 1;
        }else if(nums[mid] > target){
            right = mid;   // 注意点3
        }
    }
    return -1;
}

• 注意点1：这里的 right = nums.length，如果修改为 right = nums.length - 1，代码如何修改？

解释：这里的使用的是 [left,right)，也就是左闭右开的区间。如果使用左闭右闭的区间（right = nums.length - 1），代码修改如下：

//基本的二分查找（考虑：边界问题）
public static int search_basic(int[] nums, int target){
    int left = 0 , right = nums.length - 1;  // 注意点1
    int mid = -1;
    // 注意点2：如果此时依旧使用 “<” 作为条件，
    // 当搜索区间为 [2,2],[3,3],.. 时，区间里还有一个数没有判断，但条件已经不满足了。
    while(left <= right){  
       ....
       else if(nums[mid] > target){
            right = mid - 1;   // 注意点3
       }
    }
    return -1;
}

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

题目：https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/

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

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

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例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]

这道题可以分为两部分：1.找到值为 target 的第一个下标（左边界）。2.找到值为 target 的最后一个下标（右边界）

public static int[] search_left_right_bound(int[] nums, int target){
    int[] idx = {-1,-1};
    int left = 0 , right = nums.length - 1;
    int mid = -1;
    // 找到左边界
    while(left <= right){
        // 与 (left + right) / 2 得到的结果一致。
        // 下面这种写法可以一定程度避免 left + right 导致 int类型超过最大值。
        mid = left + (right - left) / 2;
        if(nums[mid] == target){
            
            right = mid - 1;
        }else if (nums[mid] < target){
            left = mid + 1;
        }else if(nums[mid] > target){
            right = mid - 1;
        }
    }
    if(left < 0 || left >= nums.length) return idx;

    if(nums[left] == target){
        idx[0] = left;
    }

    left = 0;
    right = nums.length - 1;
    // 找到右边界
    while(left <= right){
        // 与 (left + right) / 2 得到的结果一致。
        // 下面这种写法可以一定程度避免 left + right 导致 int类型超过最大值。
        mid = left + (right - left) / 2;
        if(nums[mid] == target){
            left = mid + 1;
        }else if (nums[mid] < target){
            left = mid + 1;
        }else if(nums[mid] > target){
            right = mid - 1;
        }
    }

    if(right < 0 ){
        return idx;
    }

    if(nums[right] == target){
        idx[1] = right;
    }

    return idx;
}

后续

【有时间会整理更多的二分查找相关的题解…】

参考

1. 《labuladong的算法小抄》
2. https://www.cnblogs.com/sunshuyi/p/12681088.html