给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

Solution

• 二分搜索算法

参考 二分搜索 的思路

# @lc code=start
class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
               
        def first_num(nums, target):
            low, high = 0, len(nums)-1
            while low<=high:
                mid = low+((high-low) >> 1)
                if nums[mid] >=target:
                    high = mid-1
                else:
                    low = mid+1
            if low >= len(nums) or nums[low] != target:
                return -1
            return low
        
        def last_num(nums, target):
            low, high = 0, len(nums)-1
            while low<=high:
                mid = low+((high-low) >> 1)
                if nums[mid] <= target:
                    low = mid+1
                else: 
                    high = mid-1
            if high < 0 or nums[high] != target:
                return -1
            return high
        
        start = first_num(nums, target)
        end = last_num(nums, target)
        return [start, end]
# @lc code=end

注：二分搜索框架

int binary_search(int[] nums, int target) {
    int left = 0, right = nums.length - 1; 
    while(left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1; 
        } else if(nums[mid] == target) {
            // 直接返回
            return mid;
        }
    }
    // 直接返回
    return -1;
}

int left_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定左侧边界
            right = mid - 1;
        }
    }
    // 最后要检查 left 越界的情况
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}


int right_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定右侧边界
            left = mid + 1;
        }
    }
    // 最后要检查 right 越界的情况
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}