二分查找——三种问题模板

---

1. 二分查找基本思想

二分查找的基本思想是将 n 个元素分成大致相等的两部分，取 a[n/2]a[n/2] 与 x 做比较：

如果 x=a[n/2]x=a[n/2] , 则找到 x , 算法中止
如果 x<a[n/2]x<a[n/2] , 则只需要在数组 a 的左半部分继续搜索 x
如果 x>a[n/2]x>a[n/2] , 则只需要在数组 a 的右半部分继续搜索 x

2. 二分查找时间复杂度

总共有 n 个元素，渐渐跟下去就是 n, n/2 , n/4 ,… k接下来操作元素的剩余个数），其中 k 就是循环的次数
O(n)=O(logn)

3. 二分查找模板

当出现以下条件时，即可考虑：

1. 待查找的数组有序或者部分有序
2. 要求时间复杂度低于 O(n)，或者直接要求时间复杂度为 O(log n)

标准的二分查找
二分查找左边界
二分查找右边界
二分查找左右边界
二分查找极值点

4. 标准模板-标准的二分查找

数组元素有序且不重复
我们以 “搜索一个数，如果存在，返回其索引，否则返回 -1” 为例，给出标准二分查找的模板：

我们定义这个区间可以为[left, right]

// 二分查找某个数
    public static int binarySearch(int[] nums, int target) {
        //标准的二分模板允许左闭右闭[left, right]
        int left = 0,right = nums.length - 1;
        while(left<=right){
            int mid = left + ((right - left)>>1);
            if(nums[mid]==target){
                return nums[mid];
            }else if(nums[mid]>target){
            	//如果mid都大于target也就是说 右边界可以缩小到mid-1
                right = mid - 1;
            }else{
            	//同理 左边界可以缩小的mid +1
                left = mid + 1;
            }
        }
        return -1;
    }

5. 二分查找边界

5.1 部分有序不重复

数组有序，但包含重复元素
数组部分有序，且不包含重复元素
[left,right)

    public static int binarySearch(int[] nums, int target) {
        //标准的二分模板允许左闭右闭[left, right)
        int left = 0,right = nums.length - 1;
        while(left<right){
            int mid = left + ((right - left)>>1);
            //收紧右边界
            if(nums[mid]>=target){
                right = mid;
            }else{
            	//收紧左边界
                left = mid + 1;
            }
        }
        return target==nums[left]?nums[left]:-1;
    }

如果有多个重复值存在，相当于找到了 重复的第一个值

5.2 数组部分有序，且包含重复元素

// 二分查找某个数的左边界
public int binarySearch(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        // 收缩左边界
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            // 收缩右边界
            right = mid;
        } else { // nums[mid] == target
            // 保守收缩右边界
            right--;
        }
    }
    
    // 打补丁
    return nums[left] == target ? left : -1;
}

6. 二分查找右边界

(left,right]

6.1 部分有序不重复

数组有序，但包含重复元素
数组部分有序，且不包含重复元素

// 二分查找某个数的右边界
public int binarySearch(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    while (left < right) {
        int mid = left + ((right - left) / 2) + 1;
        // 收缩右边界
        if (nums[mid] > target) {
            right = mid - 1;
        } else {
            // 收缩左边界
            left = mid;
        }
    }
    return nums[right] == target ? right : -1;
}

6.2 数组部分有序，且包含重复元素

// 二分查找某个数的左边界
public int binarySearch(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        // 收缩左边界
        if (nums[mid] < target) {
            left = mid;
        } else if (nums[mid] > target) {
            // 收缩右边界
            right = mid - 1;
        } else { // nums[mid] == target
            // 保守收缩右边界
            right--;
        }
    }
    
    // 打补丁
    return nums[left] == target ? right : -1;
}

7. 二分查找极值点

public int binarySearch(int[] nums){
    int left = 0;
    int right = nums.length - 1;

    while(left <= right){
        int mid = left + ((right - left) >> 1);
        // 极值点
        if (nums[mid] > nums[mid + 1] && nums[mid] > nums[mid - 1]) {
            return mid;
        } else if (nums[mid] > nums[mid + 1]){ 
            // 极值点在 mid 左边
            right = mid - 1;
        } else {
            // 极值点在 mid 右边
            left = mid + 1;
        }
    }

    return -1;
}

如有错误欢迎指正