剑指offer-53 二分查找处理大于等于边界问题

、

代码：

• 二分查找可以用while代替，逐渐习惯
• 循环的一点好处是可以轻松赋值前一个位置变量，递归每次都会更新，碰到左边界问题不好保留上次记录的值

• 对于这种找等于号边界的情况，可以把找大于等于单独作为一次二分查找确定边界，不过是两次O（logN）。 ```java class Solution { public int search(int[] nums, int target) {

    int leftIdx = binarySearch(nums, target, true);
    int rightIdx = binarySearch(nums, target, false) - 1;
    if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {
        return rightIdx - leftIdx + 1;
    } 
    return 0;

  }

  public int binarySearch(int[] nums, int target, boolean lower) {

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

  } }

作者：LeetCode-Solution 链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-wl6kr/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解法二：我的解法，在递归中判断等于号的情况，如果相等时，找左右两端中等于的情况。时间复杂度应该比上面这个差一点点，因为最差的情况是所有数都相等，我的变成了O（N）但是上面的 算法还是O（logN）级别
```java
    public int search(int[] nums, int target) {
        if(nums == null || nums.length == 0) return 0;
 if(target > nums[nums.length-1] || target < nums[0]) return 0;
        return process(nums, target, 0, nums.length-1);
    }
    public  int process(int[] nums, int target, int l , int r){
        if(l> r) return 0;
        if(l == r ){
          if(nums[l] == target) return 1;
          else  return 0;
        }
        int mid = l + ((r-l)>>1);
        int res = 0;
        if(nums[mid] < target){
            res =  process(nums, target, mid + 1, r);
        }else if(nums[mid] > target){
            res = process(nums, target, l ,mid-1);
        }else {
            res = 1 + process(nums, target, l , mid-1) + process(nums, target, mid+1, r);
        }
        return res;
    }