Leecode刷题笔记之二分查找

34. 在排序数组中查找元素的第一个和最后一个位置

附上题目链接：https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/
题目说明时间复杂度为O(logn)并且是有序数组，最先想到的就是使用二分查找来做，那么怎么来定位数组的开始位置和结束位置呢？其实还是通过二分查找来完成。

解法一

寻找target在数组里的左右边界，有如下三种情况：

• 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
• 情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
• 情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}
  然后通过两次使用二分查找，分别定位target的最左边和最右边。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftBorder = getLeftBorder(nums,target);
        int rightBorder = getRightBorder(nums,target);

        //target 在数组范围的右边或者左边
        if (leftBorder == -2 || rightBorder == -2){
            return new int[]{-1,-1};
        }
        //target 在数组范围中，且数组中存在target
        if (rightBorder - leftBorder > 1){
            return new int[]{leftBorder + 1,rightBorder - 1};
        }
        //target 在数组范围中，且数组中不存在target
        return new int[]{-1,-1};
    }

    public int getRightBorder(int[] nums, int target) {
        int left = 0,right = nums.length - 1;
        int rightBorder = -2;

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

    public int getLeftBorder(int[] nums, int target) {
        int left = 0,right = nums.length - 1;
        int leftBorder = -2;

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

解法二

直接在数组中进行二分查找，如果没有找到就直接返回{-1,-1}；如果查找成功，就返回当前target的下标，然后通过左右滑动指针的方式来找到符合区间。

class Solution {
  public int[] searchRange(int[] nums, int target) {
    int index = binarySearch(nums, target); // 二分查找
    
    if (index == -1) { // nums 中不存在 target，直接返回 {-1, -1}
      return new int[] {-1, -1}; // 匿名数组 
    }
    // nums 中存在 targe，则左右滑动指针，来找到符合题意的区间
    int left = index;
    int right = index;
        // 向左滑动，找左边界
    while (left - 1 >= 0 && nums[left - 1] == nums[index]) { // 防止数组越界。逻辑短路，两个条件顺序不能换
      left--;
    }
        // 向左滑动，找右边界
    while (right + 1 < nums.length && nums[right + 1] == nums[index]) { // 防止数组越界。
      right++;
    }
    return new int[] {left, right};
    }
  
  /**
   * 二分查找
   * @param nums
   * @param target
   */
  public int binarySearch(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1; // 不变量：左闭右闭区间
    
    while (left <= right) { // 不变量：左闭右闭区间
      int mid = left + (right - left) / 2;
      if (nums[mid] == target) {
        return mid;
      } else if (nums[mid] < target) {
        left = mid + 1;
      } else {
        right = mid - 1; // 不变量：左闭右闭区间
      }
    }
    return -1; // 不存在
  }
}