二分查找不得不说的事

关于二分查找

参考二分查找。

二分查找算法的编写框架大致如下：

int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;

    while(...) {
        int mid = (right + left) / 2;
        if (nums[mid] == target) {
            ...
        } else if (nums[mid] < target) {
            left = ...
        } else if (nums[mid] > target) { // 写成else更简化
            right = ...
        }
    }
    return ...;
}

计算mid时有技巧可以防止溢出，写成mid = left + (right - left) / 2。

查找一个数（基本的二分查找）

这个场景是最简单的，也是我们最熟悉的。搜索一个数，如果存在则返回其下标，否则返回 -1。

• 假设数组中有n个元素，下标范围为[0 : n-1]，要查询的元素为key。
• 初始化时，令min = 0, max = n-1。这里提出一个搜索区间的定义，此时算法的搜索区间就是闭区间[min, max]，搜索区间的特点决定了min, max的移动方式。
• 循环条件为while(min <= max)，计算中间元素mid = (left + right) / 2
• if A[mid] > key, then max = mid - 1
• if A[mid] < key, then min = mid + 1
• 因为搜索区间两边都是闭的，所以min, max移动时都是需要加一或者减一
• 该算法的终止条件要么为nums[mid] = target，要么为left = right + 1。

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1; // 注意

    while(left <= right) { // 注意
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1; // 注意
        else if (nums[mid] > target)
            right = mid - 1; // 注意
    }
    return -1;
}

• 注意啊注意，如果不修改min, max移动方法的话，最基本的二分查找不可以直接修改为min=0. max=n, while(min < max)这种写法，可以举个例子，nums = [1, 2, 3], target = 1，min=0, max=3, mid=1, nums[1] > target，移动max之后min = max直接结束，所以这种写法是错的。
• 如果非要写成min = 0, max = n, while(min < max)，那么移动时left = mid + 1不用动，但是right = mid！
• 初始化，min = 0, max = n。那么此时算法的搜索区间为左闭右开的[left, right)。
• 循环条件为while(min < max)，计算中间元素mid = (left + right) / 2
• if A[mid] > key, then max = mid！！！！！
• if A[mid] < key, then min = mid + 1
• 该算法的终止条件要么为nums[mid] = target，要么为left = right。

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length; // 注意

    while(left < right) { // 注意
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1;
        else if (nums[mid] > target)
            right = mid; // 注意
    }
    return -1;
}

也就是说，初始化的min, max决定了搜索区间的特性，进而决定了算法中循环的判断条件以及min, max的移动方式。（即，修改min. max的初始化条件的话，只需要修改while内的判断条件以及min, max的移动方式即可）

二分查找的变种

参考二分查找的变种：其中链接中的的2.5, 2.6写的有问题，没有考虑min可能越界的情况，正确写法参考下面的5, 6。

关于二分查找，如果条件稍微变换一下，比如：数组之中的数据可能可以重复，要求返回匹配的数据的最小（或最大）的下标；更进一步， 需要找出数组中第一个大于key的元素（也就是最小的大于key的元素的）下标，等等。 这些，虽然只有一点点的变化，实现的时候确实要更加的细心。

二分查找的变种和二分查找原理一样，主要就是变换判断条件（也就是边界条件）。

1. 查找第一个与key相等的元素

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            right = mid - 1; // 算法能够搜索第一个key的关键所在！！
        else if (nums[mid] < target)
            left = mid + 1;
        else if (nums[mid] > target)
            right = mid - 1;
    }
    
    if(left < nums.leghth && nums[left] == target) {
        return left; 
    }
    
    return -1; // 还有可能没有找到！
}

• 因为初始化left = 0, right = n - 1，循环条件中为left <= right，因此循环终止条件为left = right + 1，所以left的取值范围为[0, n]，所以最后需要判断left < nums.length?。
• 假设搜索过程的中间过程中就遇到了第一个与key相等的元素，我们称此时的mid为final，那么下一步搜索区间会变成[left, final - 1]，因为这个区间里面全是小于 key 的元素，所以最后结束时，left = final, right = final - 1，left整好指到了第一个与 key 相等的元素位置。
• 假设搜索的最后一步才遇到与 key 相等的元素，也就是left = right = final，下一步left = final, right = final - 1，不满足循环条件终止。此时left同样指向了第一个也是唯一一个与 key 相等的元素位置。

分析的时候，将nums[mid]与target的关系分三部分进行讨论，分析完可以合并：

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] >= target) // 合并
            right = mid - 1;
        else if (nums[mid] < target)
            left = mid + 1;
    }
    
    if(left < nums.leghth && nums[left] == target) {
        return left;
    }
    
    return -1;
}

2. 查找最后一个与key相等的元素

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] <= target)
            left = mid + 1;
        else if (nums[mid] > target)
            right = mid - 1;
    }
    
    if(right >= 0 && nums[right] == target) {
        return right;
    }
    
    return -1;
}

3. 查找最后一个小于或等于key的元素

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] <= target)
            left = mid + 1;
        else if (nums[mid] > target)
            right = mid - 1;
    }
    
    if(right >= 0 && nums[right] <= target) {
        return right;
    }
    
    return -1; // 还有可能没有找到！
}

其实最后可以直接写成reutrn right，因为对于特殊情况，没有小于等于 key 的元素，也就是所有的都大于 key，那么在搜索过程中left一直不变，right一直在减小，结束时left = 0, right = -1，要返回的就是-1；

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] <= target)
            left = mid + 1;
        else if (nums[mid] > target)
            right = mid - 1;
    }
    
    return right;
}

4. 查找最后一个小于key的元素

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] < target)
            left = mid + 1;
        else if (nums[mid] >= target)
            right = mid - 1;
    }
    
    return right;
}

5. 查找第一个大于或等于key的元素

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] >= target)
            right = mid - 1;
        else if (nums[mid] < target)
            left = mid + 1;
    }
    
    if(left < nums.length && nums[left] >= key) {
        return left;
    }
    return -1;
}

6. 查找第一个大于key的元素

int binarySearch(int[] nums, int target) {
    int left = 0; 
    int right = nums.length - 1;

    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] > target)
            right = mid - 1;
        else if (nums[mid] <= target)
            left = mid + 1;
    }
    
    if(left < nums.length && nums[left] > key) {
        return left;
    }
    return -1;
}