【二分查找】二分查找的基本实现和另外两个实现方式，笔试常见的二分查找的试题

不是出自名校,我也要查漏补缺,我想拿到自己满意的offer

一次一次刻意的去练习基础,让自己的基本功更加熟练,加油

二分查找

在最简单的形式中，二分查找对具有指定左索引和右索引的连续序列进行操作。这就是所谓的查找空间。二分查找维护查找空间的左、右和中间指示符，并比较查找目标或将查找条件应用于集合的中间值；如果条件不满足或值不相等，则清除目标不可能存在的那一半，并在剩下的一半上继续查找，直到成功为止。如果查以空的一半结束，则无法满足条件，并且无法找到目标。

简单二分查找的实现

根据二分查找的思想写出代码

class Solution {
    public int search(int[] nums, int target) {
        //判断数组是否存在  判断数组的长度是否为0(数组是否是一个空数组)
        if(nums == null||nums.length ==0){
            return -1;
        }
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (right - left)/2 + left;
            if(nums[mid] == target){
                return mid;
            }
            if(nums[mid] < target){
                left = mid + 1;
            }
            else{
                right = mid - 1;
            }
        }
        return -1;
    }
}

如何实现一个二分查找

• 已排序
  • 二分查找是根据空间索引判断目标值出现的位置,每次排除一半的位置,那么要排除不符合的部分,就要求之前的序列是有序的
• 二分查找
• 后处理:对于剩余空间中确定可行者

二分查找的三种模板

1.第一种实现方式

class Solution {
    public int search(int[] nums, int target) {
        //判断数组是否存在  判断数组的长度是否为0(数组是否是一个空数组)
        if(nums == null||nums.length ==0){
            return -1;
        }
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (right - left)/2 + left;
            if(nums[mid] == target){
                return mid;
            }
            if(nums[mid] < target){
                left = mid + 1;
            }
            else{
                right = mid - 1;
            }
        }
        return -1;
    }
}

初始条件: left = 0,right = nums.length - 1

终止 left > right

向左查找: right = mid - 1

向右查找 : left = mid + 1

• 查找条件可以在不与元素的两侧进行比较的情况下确定（或使用它周围的特定元素）。
• 不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素。

2.第二种实现方式

class Solution {
    public int search(int[] nums, int target) {
        if(nums == null || nums.length == 0){
            return -1;
        }
        int left = 0;
        int right = length;
        while(left < right){
            int mid = (right - left)/2 + left;
            if(nums[mid] == target){
                return mid;
            }
            if(num[mid] < target){
                left = mid + 1;
            }else{
                right = mid;
            }
        }
        if(left !=nus.length &&nums[left] == target){
            return left;
        }
        return -1;
    }
}

初始条件: left = 0,right = nums.length

终止 left == right

向左查找: right = mid

向右查找: left = mid + 1

• 使用元素的右邻居来确定是否满足条件，并决定是向左还是向右
• 保证查找空间在每一步中至少有 2 个元素。
• 需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件。

3.第三种实现方式

int binarySearch(int[] nums, int target) {
    if (nums == null || nums.length == 0)
        return -1;

    int left = 0, right = nums.length - 1;
    while (left + 1 < right){
        // Prevent (left + right) overflow
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid;
        } else {
            right = mid;
        }
    }

    // Post-processing:
    // End Condition: left + 1 == right
    if(nums[left] == target) return left;
    if(nums[right] == target) return right;
    return -1;
}

• 搜索条件需要访问元素的直接左右邻居。
• 使用元素的邻居来确定它是向右还是向左。
• 保证查找空间在每个步骤中至少有 3 个元素。
• 需要进行后处理。 当剩下 2 个元素时，循环 / 递归结束。 需要评估其余元素是否符合条件。

经典题目练习

1.x的平方根

class Solution {

    public int mySqrt(int x) {
        //为了照顾数字0的平方根,我们将其设置为0
        int left = 0;
        //我们期望的是得到的是该数的右边界
        int right = x/2 + 1;
        while (left < right){
            int mid = (left + right +1 ) >>>1;
            if (mid * mid > x){
                right = mid - 1;
            }else {
                left = mid;
            }
        }
        return (int)left;
    }

}

2.第一个错误的版本

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        //这个题目的思路已经给的很明确了
        //题目的意思实现查找到错误的版本,可以理解为查找到某个数
        //给的条件:   n个版本中有一个错误版本
        //left定义为1,最小的推出的版本就是第一个版本
        int left = 1;
        int right = n;
        while (left < right){
            int index = (right - left)/2+ left;
            if (isBadVersion(index)){
                right = index ;
            }else {
                left = index +1;
            }
        }
        return left;

        //或者直接使用暴力解法,直接循环,然后判断,但是不满足尽量少调用外部方法的作法
//        for (int i = 1; i <= n ; i++) {
//            if (isBadVersion(i)){
//                return i;
//            }
//        }
    }
}

3.在排序数组中查找数字

分析:

1. 数组已排序
2. 统计次数

思路:

1. 暴力求解(遍历数组,对照每个值是不是和目标值相同)
2. 二分查找(减少了对照元素的次数)

二分查找代码实现

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

总结

• 有序的数组中经常要使用二分查找
• 使用二分查找的意义就是帮我们优化了查找元素时需要执行查找的次数。