二分查找的一些总结

二分查找

在一个范围内，查找一个数字，要求找到这个元素的开始位置和结束位置，这个范围内的数字都是单调递增的，即具有单调性质，因此可以使用二分来做。二分查找的前提是数组中的数据必须有序。

注意，数组中的元素可能是严格单调递增，即数组中不存在重复元素；也可能是单调非严格递增，即存在连续的相等子序列。

源码中的二分查找：若返回正数，则找到 target 并返回索引；若没有找到 target，则返回 target 应该处于的索引位置（首个大于 target 的元素的索引位置）的取反。但是此种方法要求数组严格单调递增，即不存在重复元素。

public int binarySearch(int[] nums, int fromIndex, int toIndex, int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        // int mid = (high - low) / 2 + low;
        if (nums[mid] < key)
            low = mid + 1;
        else if (nums[mid] > key)
            high = mid - 1;
        else
            return mid;   // key found.
    }
    return -(low + 1);    // key not found.
}

二分查找的变化

取 mid 时，mid = (low + high) / 2 是对 low 和 high 的中间值向下取整，即当 [low, high] 的元素个数为偶数时 mid 落在靠近 low 的位置。当 low 与 high 相加可能会造成越界时，使用 mid = ((high - low) / 2) + low 可以防止越界，同样为向下取整。

mid = (low + high + 1) / 2 是对 low 和 high 的中间值向上取整，即当 [low, high] 的元素个数为偶数时 mid 落在靠近 high 的位置。当 low 与 high 相加可能会造成越界时，使用 mid = ((high - low + 1) / 2) + low 可以防止越界，同样为向上取整（此式子的意义是，high - low + 1 是计算得到 [low, high] 范围内元素的个数，当个数为奇数时，(high - low + 1) / 2 得到的是数量偏少的一部分，与 low 相加即为中点的索引；当个数为奇数时，(high - low + 1) / 2 得到的是数量是总数的一半，与 low 相加即为右半部分的首个位置）。

mid 两侧开区间内搜索

根据 mid 处元素的值，选择 [low, mid) 或 (mid, high] 范围内继续搜索。数组中可以存在重复元素，若存在多个重复的 key。

对于不存在的元素，需要使用第一种方法，才能返回其应该处于的位置，也即第一个大于 key 的位置。对于大于数组最后一个元素的 key，也可以返回其应该处于的位置。

下方两种方法，本质是一致的，也即返回的 low 是满足 low = mid + 1 的条件中最后一个 mid 对应位置的下个元素，返回的 high 是满足 high = mid - 1 的条件中第一个 mid 对应位置的上个元素。如 if (key <= nums[mid]) high = mid - 1; 则返回的 high 就是小于 key 的最后一个元素所在的位置，返回的 low 就是大于等于 key 的第一个元素所在的位置；if (key > nums[mid]) low = mid + 1; 则返回的 low 就是大于等于 key 的第一个元素所在的位置，返回的 high 就是小于 key 的最后一个元素所在的位置。

选择数组中大于等于 key 的首个元素的位置

此方法可以找到值等于 key 的首个元素的下标；若数组中不存在值为 key 的元素，则返回的是首个大于 key 的元素的位置。

对于此方法，while 循环结束的条件是 low > high，因此一定是由 low == high 再经过对 low 或 high 变化到 low > high 从而退出循环，因此对 mid 选择向上或向下取整，并不影响结果。

• 假设最后一次是由 key <= nums[mid] 而执行 high = mid - 1，导致 low > high 遍历结束，那么此 mid 就是大于等于 key 的最小索引，此时 mid = low，但不等于 high。
• 对于不存在的 key，相当于没有等于的情况，则退出循环时，low 就是第一个大于 key 的元素索引，也是 key 在数组中应该排在的位置。
• 相反，如果由于 key > nums[mid] 而执行 low = mid + 1，导致 low > high 遍历结束，那么此 mid 就是小于 key 的最大索引，此时 mid = high，但不等于 low，low 还是大于等于 key 的元素索引。

在 key == nums[mid] 时使范围右界减小，搜索趋势为向左，因此找到的是最靠左的值为 key 的元素索引。

关键在于对 key == nums[mid] 时的情况进行分析，有可能在 mid 附近有多个值与 key 相同的元素：

• 假设 mid 处是连续多个 key 值元素的第一个，则当 high = mid - 1 时，low~high 范围内的值全部小于 key，此时 low 会一直被赋值 mid+1，直到 low > high，此时的 low 刚好处于连续多个 key 值元素的第一个，返回即可。
• 假设 mid 处是连续多个 key 值元素的第二个及往后，则当 high = mid - 1 时，变化后的 low~high 范围内会存在多个置为 key 的元素，且会堆积在靠后部分。如果新的 mid 值还是 key，则循环判断即可；如果新的 mid 值不为 key，则一定小于 key，此时 low = mid + 1，继续判断后半部分。

此方法对于多个值等于 key 的子序列处理的思想是，找到值为 key 的子区间 mid~high，不断缩小 high 的范围，直到 high 处的值小于 key，再利用 low 增加使其回到首个 key 的位置。

public int binarySearch(int[] nums, int fromIndex, int toIndex, int key) {
    int low = fromIndex;
    int high = toIndex - 1;
    // 循环结束条件是low>high
    while (low <= high) {
        // int mid = (low + high) / 2;
        int mid = ((high - low) / 2) + low;
        // 最后一步一定会到达 low=mid=high 的情况
        // 假设最后一次由于 key<=nums[mid] 而使得 high=mid-1，导致 low>high 遍历结束
        // 那么此 mid 就是大于等于 key 的最小索引，mid=low，但不等于 high
        // 对于不存在的 key，相当于没有 = 的情况，则退出循环时，low 就是第一个大于 key 的元素索引
        // 相反，如果由于 key>nums[mid] 而使得 low=mid+1，导致 low>high 遍历结束
        // 那么此 mid 就是小于 key 的最大索引，mid=high，但不等于 low，low 还是大于等于 key 的
        if (key <= nums[mid]) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return low;
    // return high; 则返回的是比key小的最后一个元素的索引
}

选择数组中小于等于 key 的最后一个元素的位置

此方法可以找到值等于 key 的最后一个元素的下标；若数组中不存在值为 key 的元素，则返回的是最后一个小于 key 的元素的位置。

此方法里，由于退出循环的条件是 low > high，向上取整与向下取整不影响结果。

在 key == nums[mid] 时使范围左界增大，搜索趋势为向右，因此找到的是最靠右的值为 key 的元素索引。

public int binarySearch(int[] nums, int fromIndex, int toIndex, int key) {
    int low = fromIndex;
    int high = toIndex - 1;
    // 循环结束条件是low>high
    while (low <= high) {
        // int mid = (low + high + 1) / 2;
        int mid = ((high - low + 1) / 2) + low;
        if (key < nums[mid]) {
            high = mid - 1;
        } else {
            // 此方式时将等于的情况划在 key<=nums[mid] 一起考虑
            // 则返回的 low 一定是大于 key 的第一个，high 是小于等于 key 的最后一个
            low = mid + 1;
        }
    }
    return high;
    // return low; 则返回的是比key大的第一个元素的索引
}

mid 两侧一开一闭区间内搜索

根据 mid 处元素的值，选择 [low, mid] 或 (mid, high] | [low, mid) 或 [mid, high] 范围内继续搜索。

对于不存在的元素，需要使用第一种方法，才能返回其应该处于的位置，也即第一个大于 key 的位置。对于大于数组最后一个元素的 key，不可以返回其应该处于的位置。

关于两侧开区间与一开一闭方法，第二种方法不能求出大于数组最后一个元素的 key 应该处于的位置，其它方面一致。

下方两种方法，本质也是一致的，也即 在向下取整中，返回的 low 是满足 high = mid 的条件中第一个 mid 对应位置的下个元素；在向上取整中，返回的 low 是满足 low = mid 的条件中最后一个 mid 对应位置的上个元素。如在向下取整中， high = mid; 对应的条件是 key <= nums[mid]，则返回的 low（等于 mid） 就是大于等于 key 的第一个元素所在的位置（若对应条件没有等于，则返回的就是大于 key 的第一个元素所在的位置）；在向上取整中，low = mid; 对应的条件是 key >= nums[mid]，则返回的 low（等于 mid） 就是小于等于 key 的最后一个元素所在的位置（若对应条件没有等于，则返回的就是小于 key 的最后一个元素所在的位置）。

选择数组中大于等于 key 的首个元素的位置

此方法可以找到值等于 key 的首个元素的下标；若数组中不存在值为 key 的元素，则返回的是首个大于 key 的元素的位置（key 不能大于数组末尾元素）。

对于此方法，while 循环结束的条件是 low == high，因此一定是由 low + 1 = high 再经过对 low 或 high 变化到 low == high 从而退出循环。由于对 mid 采用向下取整，因此在 low + 1 = high 的情形下 mid 一定落在 low 处，因此为了可以跳出循环，因此必然对 low 赋予 mid + 1。也即，对 mid 向下取整与 low = mid + 1 是绑定的。

对于 mid 的选取，需要向下取整，同时 key == nums[mid] 的情形需要并在 key > nums[mid] 时一同考虑。选取首个元素是由向下取整决定的，选择的是大于等于 key 的元素是由 key == nums[mid] 并在 key > nums[mid] 一同考虑觉定的。

• 由于向下取整，则最后一步操作始终伴随着 if (key > nums[mid]) low = mid + 1; 也即此时的 low 是首个大于等于 key 的元素，因此是首个。
• 由于 if (key > nums[mid]) low = mid + 1; 因此是首个大于等于。若 if (key >= nums[mid]) low = mid + 1; 则得到的是首个大于 key 的元素的索引。

public int myBinarySearch(int[] nums, int fromIndex, int toIndex, int key) {
    int low = fromIndex;
    int high = toIndex - 1;
    // 循环结束条件是low=high
    while (low < high) {
        // mid是low与high中点向low偏移
        int mid = (low + high) >>> 1;
        // int mid = (high - low) / 2 + low;
        if (key > nums[mid])
            low = mid + 1;
        else
            high = mid;
    }
    return low;
}

选择数组中小于等于 key 的最后一个元素的位置

此方法可以找到值等于 key 的最后一个元素的下标；若数组中不存在值为 key 的元素，则返回的是最后一个小于 key 的元素的位置。

对于此方法，while 循环结束的条件是 low == high，因此一定是由 low + 1 = high 再经过对 low 或 high 变化到 low == high 从而退出循环。由于对 mid 采用向上取整，因此在 low + 1 = high 的情形下 mid 一定落在 high 处，因此为了可以跳出循环，因此必然对 high 赋予 mid - 1。也即，对 mid 向上取整与 high = mid - 1 是绑定的。

对于 mid 的选取，需要向上取整，同时 key == nums[mid] 的情形需要并在 key < nums[mid] 时一同考虑。选取首个元素是由向上取整决定的，选择的是小于等于 key 的元素是由 key == nums[mid] 并在 key < nums[mid] 一同考虑觉定的。

• 由于向上取整，则最后一步操作始终伴随着 if (key < nums[mid]) high = mid - 1; 也即此时的 high 是最终小于等于 key 的元素，因此是最后一个（high = mid - 1 导致 key < nums[mid] 不成立）。
• 由于 if (key < nums[mid]) high = mid - 1; 因此是最后一个小于等于。若 if (key <= nums[mid]) high = mid - 1; 则得到的 high 是最后一个小于 key 的元素的索引。

public int myBinarySearch(int[] nums, int fromIndex, int toIndex, int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low < high) {
        int mid = (low + high + 1) >>> 1;
        // int mid = (high - low + 1) / 2 + low;
        if (nums[mid] <= key)
            low = mid;
        else
            high = mid - 1;
    }
    return low;
}