二分查找深入剖析

非常值得注意的一点

我们在取mid的时候，无论是直接
left+(right-left)/2
还是(left+right)>>>1
做的都是整数除法，都是向下取整，这么一来，如果我们在处理left指针的时候，单纯的让left = mid，可能会出现下面这种情况

left = n, right = n+1; key位于left和right之间，之后left、right、mid的变动会出现死循环

                                **********************
                                * left * mid * right *
                                **********************
                                *  n   *  n  *  n+1  *
                                **********************
                                *  n   *  n  *  n+1  *
                                **********************
                                *  n   *  n  *  n+1  *
                                **********************
                                *       ......       *
                                **********************

所以，如果用向下取整，那么我们一定要移动 left 指针

针对边界的四种思路

处理二分查找的边界问题，根本的一点就是保持区间的一致性

• 左闭右闭
• 左闭右开
• 左开右闭
• 左开右开

左闭右闭

JDK里的数组二分查找就是用的这种,循环终止条件是 left>right

//JDK里的代码
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex;
        int high = toIndex - 1;//因为是闭区间，而toIndex是不在区间内的，所以需要-1

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            //这里的low和high分别在mid上进行加一和减一操作，也与左闭右闭保持了一致性
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        //这里针对 low==0 而无法判断是否找到的情况
        return -(low + 1);  // key not found.
    }

左闭右开

注意循环终止条件变成了 left == right

public static int binarySearch1(int[] nums, int target) {
        if(nums == null || nums.length == 0)return -1;
        int left = 0,right = nums.length;
        //注意循环终止条件变了
        while (left < right) {
            int mid = (left+right)>>>1;
            if(target == nums[mid])
                return mid;//右开区间，即右指针永远指向搜索区间外
            else if(target<nums[mid])
                right = mid;
            else if(target>nums[mid])
                left = mid+1;
        }
        //循环终止条件是 left == right，而right永远指向搜索区间外，即此时一定是没有找到target
        return -1;
    }

左开右闭

public static int search3(int[] nums, int target) {
        if(nums == null || nums.length==0)return -1;
        int left = -1, right = nums.length-1;
        //循环终止条件依然是 left == right
        while (left < right) {
            //注意这里做了+1，相当于向上取整
            int mid = (left+right+1)>>>1;
            int midVal = nums[mid];
            if(target == midVal)
                return mid;
            else if(target<midVal)
            //右闭区间，指向搜索区间内
                right = mid-1;
            else
            //左开区间，指向搜索区间外
                left = mid;
        }
        //在这里可能会有这么一个疑问：如果最后一步是left移动，导致了left==right，此时循环终止了，而right依然在搜索区间内，且没有经过再一次的排除
        //如果是上面这种情况的话，只能是left与right紧挨着，这个时候才会有 left == mid == right，而出现这种情况时，mid也是等于right的，而针对mid，我们之前已经检查过了，如果mid处，也就是right处是target的时候，早已return了
        return -1;
    }

左开右开

这个时候的循环跳出条件变成了 left < right-1，所以就不会出现之前的死循环的情况

public static int search4(int[] nums,int target){
        int left = -1,right = nums.length;
        while (left < right-1) {
            System.out.println("left:"+left+" right:"+right);
            int mid = (left+right)>>>1;
            int midVal = nums[mid];
            if(target == midVal)
                return mid;
            if(target<midVal)
                right = mid;
            else
                left = mid;
        }
        return -1;
    }

关于取左边界、右边界的问题

首先要确定左右边界的定义

• 左边界：对于左边界index，任何索引号小于index的元素都小于target，任何索引号大于等于index的，都大于等于target
• 有边界：对于有边界index，任何索引号小于index的元素都小于等于target，任何索引号大于index的，都大于target

左边界

由定义可知，左边界的取值范围是 0—nums.length，显然需要一个右开区间，而左开右开区间中间会差一个值，可能会比较麻烦，所以我们选用左闭右开区间的模型

//模型保证的是不会出现死循环
public static int leftSearch(int[] nums, int target) {
    int l = 0,r = nums.length;
    while (l < r) {
        int mid = (l+r)>>>1;
        //如果数组中不存在target，那就相当于寻找target的插入位置
        //如果遇到target的值，用==的意思就类似于假装它不存在
        if (target <= nums[mid]) {
            r = mid;
        }else
            l = mid+1;
    }
    return l;
}

右边界

与左边界基本一样

public static int rightSearch(int[] nums, int target) {
    int l =0,r = nums.length;
    while (l < r) {
        int mid = (l+r)>>>1;
        if(target>=nums[mid])
            l = mid+1;
        else
            r = mid;
    }
    //为什么要减一？
    //1,2,2,2,3,3中，2的左边界插入位置就是1，就是符合题意的答案
    //2的有边界插入位置是最后一个2的右边，刚好是答案的偏移一位，所以需要-1
    return l-1;
}