算法系列——二分查找算法及其变体总结

基础二分查找

基本二分查找的程序代码如下所示

        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = (left + right) / 2;
            //target 在左边
            if (target < nums[mid])
                right = mid - 1;
                //target 在右边
            else if (target > nums[mid])
                left = mid + 1;
            else
                return mid;
        }
        return -1;

基础二分查找只能找到指定target在序列中的位置，假如target有重复值，二分查找只能返回其中某个target的位置，这个位置并不确定，主要跟target值的起始位置和重复序列的长度有关系。

二分查找变体

在基础二分查找的代码中,加入在while循环中不执行返回退出操作，判断条件做稍微改动，其实只是去掉了返回操作，只剩一个if-else判断。

    //target 在左边
    if (target < nums[mid])
        right = mid - 1;
    //target 在右边
    else
        left = mid + 1;

那么最终 left,right关系是 right+1=left.

举个栗子，例如 nums={ 1,2,3,3,3,3,4,5 } target=3
当 判断条件为if (target <= nums[mid]) ... else时，最终位置状态为

1,2(right),3(left),3,3,3, 4,5
right left的位置卡在target序列的左边界。
当判断条件为 if (target < nums[mid]) ... else时，最终位置状态为

1,2,3,3,3,3(right),4(left),5
right left的位置卡在target序列的右边界。
那么假如target不存在呢？比如 nums={1,2,4,5} target=3

当 判断条件为if (target <= nums[mid]) ... else时，最终位置状态为

1,2(right),4(left),5
当判断条件为 if (target < nums[mid]) ... else时，最终位置状态为

1,2(right),4(left),5

从以上的分析中可以看到，left,right 总是停留在target元素的附近，并且还有一定的规律。

其实根据不同的条件下left,right位置信息，我们可以利用二分查找还能能解决以下6个问题：

返回第一个=target的元素位置,此时判断符号<= 要返回left；
返回第一个>=target的元素位置,此时判断符号<= 要返回left；
返回第一个>target的元素位置，此时判断符号<要返回left；
返回最后一个=target的元素位置,此时判断符号<，要返回right；
返回最后一个<=target的元素位置,此时判断符号位<,返回right；
返回最后一个< target的元素位置,此时判断符号位<=,返回right。

以上问题都可以套用如下二分查找的结构：

····
      //条件必须是 <=
        while (left <= right) {
           mid = left + (right-left) / 2;
            //target 在左半部分
            if (target ➀ nums[mid])
                right = mid - 1;
                //target 在右边部分
            else if (target > nums[mid])
                left = mid + 1;
        }
       ...
        return ➁;

➀ 所在位置的比较符号要么是< 要么是<=
➁ 位置要么是 left要么是right.

下表给出六种情况下➀➁处的取值。

问题	➀处符号	➁处值
返回第一个=target	<=	left
返回第一个>=target的元素位置	<=	left
返回第一个>target的元素位置	<	left
返回最后一个=target的元素位置	<	right
返回最后一个<=target的元素位置	<	right
返回最后一个< target的元素位置	<=	right

如何记忆

那么如果我们碰到以上6种情况，但没表可以查怎么办，其实也比较好解决，
首先程序结构要按以上给出的结构来写，那么根据问题，确定出问题在哪一种种判断条件下才能取得结果，是< 还是 <= ，其次确定出 应该返回left 还是right.
比如要求 第一个大于> target的元素位置，那right left 必定卡在 target序列的右边界，此时判断条件只能是 <,并且 应该返回 left。

程序实现

下面给出所有情况的具体程序实现，实际运用时要弄懂问题要求，再按照具体情况给出不同的解答。

public class Solution {
    /**
     * 基础二分查找
     *
     * @param nums
     * @param target
     * @return
     */
    public int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边
            if (target > nums[mid])
                right = mid - 1;
                //target 在右边
            else if (target < nums[mid])
                left = mid + 1;
            else
                return mid;
        }
        return -1;
    }
    //----------以下是二分查找的6种变体情况-------------
    // nums={ 1,2(right),3(left),3,3,3(right) 4(left),5 }  target=3
    // nums={1,2(right),4(left),5}  target=3
    //1. first  =(left(<=)) >=(left(<=)) >(left(<))
    //2. last   =(right(<)) <=(right(<)) <(right(<=))


    /**
     * 找第一个大于target的元素位置 符号必须是<
     *
     * @param nums
     * @param target
     * @return
     */
    public int findFirstGreater(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边
            if (target < nums[mid])
                right = mid - 1;
                //target 在右边
            else
                left = mid + 1;

        }
        return left;
    }

    /**
     * 查找第一个大于等于target的元素位置 符号是<= 保证 left有指向target的机会
     *
     * @param nums
     * @param target
     * @return
     */
    public int findFirstGreaterEqual(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边 条件是 target> nums[mid]
            if (target <= nums[mid])
                right = mid - 1;
                //target 在右边
            else
                left = mid + 1;

        }
        return left;
    }

    /**
     * 查找第一个等于target的元素位置 符号是<=
     *
     * @param nums
     * @param target
     * @return
     */
    public int findFirstEqual(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边
            if (target <= nums[mid])
                right = mid - 1;
                //target 在右边
            else
                left = mid + 1;

        }
        //判断边界
        if (left < nums.length && nums[left] == target)
            return left;
        return -1;
    }


    /**
     * 查找最后一个=target的元素位置 符号是<
     *
     * @param nums
     * @param target
     * @return
     */
    public int findLastEqual(int[] nums, int target) {

        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边
            if (target < nums[mid])
                right = mid - 1;
                //target 在右边
            else
                left = mid + 1;

        }
        if (right >= 0 && nums[right] == target)
            return right;
        return -1;

    }

    /**
     * 查找最后一个 @param nums
     * @param target
     * @return
     */
    public int findLastLess(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边
            if (target <= nums[mid])
                right = mid - 1;
                //target 在右边
            else
                left = mid + 1;

        }
        return right;
    }

    /**
     * 查找最后一个<=target的元素位置 <
     *
     * @param nums
     * @param target
     * @return
     */
    public int findLastLessEqual(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        //条件必须是 <=
        while (left <= right) {
            mid = left + (right-left) / 2;
            //target 在左边
            if (target < nums[mid])
                right = mid - 1;
                //target 在右边
            else
                left = mid + 1;

        }
        return right;
    }
}