二分查找及其变种汇总

基本二分查找

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。由于二分查找的时间复杂度为O(log n)，所以在遇到有序数组，优先考虑二分查找。
二分查找最容易遇到的错误就是边界问题。

	// 1.经典二分查找，有序数组无重复数据，查找等于给定值的元素
    public static int bSearch(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] == value) {
                return mid;
            } else if (arr[mid] < value) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return -1;
    }

这里的mid = low + ((high - low) >> 1)，部分小伙伴会疑惑为啥不写mid=(high-low)/2，这样写容易在处理low和high都比较大的时候，会出现溢出，同时，由于计算机中的位运算要快于除法运算，所以用了移位操作代替除2。

二分查找的变种

变种一：有序数组存在重复数据，查找第一个值等于给定值的元素

	public static int bSearch1(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] < value) {
                low = mid + 1;
            } else if (arr[mid] > value) {
                high = mid - 1;
            } else {
                if (mid == 0 || arr[mid - 1] != value) return mid;
                high = mid - 1;
            }
        }
        return -1;
    }

变种2：有序数组存在重复数据，查找最后一个值等于给定值的元素

	public static int bSearch2(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] < value) {
                low = mid + 1;
            } else if (arr[mid] > value) {
                high = mid - 1;
            } else {
                if (mid == 0 || arr[mid - 1] != value) return mid;
                low = mid + 1;
            }
        }
        return -1;
    }

变种3：查找第一个等于或者大于value的元素，查找第一个等于或者大于value的元素，也就是说查找value值的元素有好多个，返回这些元素最左边元素的下标；如果没有等于value值的元素，则返回大于value的最左边元素的下标。

    public static int bSearch3(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        if (arr[high] < value) return -1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] >= value) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }

变种4：有序数组存在重复数据，查找第一个大于给定值的元素

 public static int bSearch4(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        if (arr[high] < value) return -1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] > value) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }

变种5：
查找最后一个等于或者小于key的元素。查找最后一个等于或者小于key的元素，也就是说等于查找key值有很多，返回这些元素最右边的元素的下标；如果没有等于key值的元素，则返回小于key值的最右边元素的下标。

 public static int bSearch5(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        if (arr[high] < value) return -1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] > value) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return high;
    }

变种6：查找最后一个小于key的元素。查找最后一个小于key的元素，也就是说返回小于key的最右边的元素下标。

 public static int bSearch6(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        if (arr[high] < value) return -1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (arr[mid] >= value) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return high;
    }

二分查找变种的题目有很多，这里附上一道：
在排序数组中查找数字 I

总结

二分查找步骤：
首先判断首返回的是low还是high。因为最后跳出while（low<=high）循环条件是high<low并且high=low-1.最后high和low一定是卡在“边界值”的左右两边，比如：如果是比较值为value，查找大于等于value的元素，则边界值就是等于value的所有元素的最左边那个，其实应该返回low。