【在排序数组中查找元素的第一个和最后一个位置】二分查找法，中等难度

一、题目

二、解法

二分查找法的基本过程可见：link
我认为该问题可以先通过二分查找法找到任意一个等于target的元素，然后在其前后进行遍历，从而找到开始位置和结束位置。需要注意的是考虑某些特殊情况的返回值：

• nums为空时，直接返回[-1, -1]；
• begin为0和end为n-1的情况要有不同的返回值；

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int n = nums.size();
        if (n==0) return {-1, -1};
        int left = 0, right = n-1;
        int begin = 0, end = 0;
        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{
                begin = mid;
                while (begin > 0 && nums[begin] == target){
                    begin--;
                }
                end = mid;
                while (end < n-1 && nums[end] == target){
                    end++;
                }
                if (nums[0]==target && nums[n-1]==target){
                    return {begin, end};
                }
                else if (nums[0]!=target && nums[n-1]==target){
                    return {begin+1, end};
                }
                else if (nums[0]==target && nums[n-1]!=target){
                    return {begin, end-1};
                }
                else{
                    return {begin+1, end-1};
                }
                
            }
        }
        return {-1, -1};
    }
};

另一种解法：我的解法可能比较繁琐，看完官方解法以后，是采用二分法来对target的左右边界进行查找。可以分别写出查找左边界和右边界的函数。

• 查找左边界：我们可以依然沿用二分查找法查找target元素的代码，不过在找到nums[mid]=target时，不要返回索引值，而是要更新查找范围，也就是说mid位置处的元素等于target，mid左边的元素可能还会有等于target的元素，那么我们不如直接更新right为mid-1，在左边范围内继续查找target直到left=right，左区间的元素肯定都查找了一遍（因为在不断更新right）。此时进入循环后，该位置元素等于target，right=mid-1，所以如果target元素存在，应该返回的是left。
• 需要注意的是，要考虑以下三种特殊情况：
  1）target小于nums中的所有元素，right会一直往左移直到left等于right，最后一次循环，right=mid-1，此时left=0，nums[left] != target，此时返回-1；
  2）target大于nums中的所有元素，left会一直往右移直到left等于right，最后一次循环，left=mid+1=nums的长度，此时返回-1；
  3）target大于nums的最小值，小于nums的最大值，但在nums中不存在，例如第一个例子中的9，此时当循环结束以后，left的值肯定不等于target，nums[left] != target时， 返回-1。
  根据上述分析，右边界寻找也是同理，可以写出以下python代码：注意先写left == len(nums)，再写nums[left] != target以防止当left = 数组长度时，发生数组越界，right也是如此。

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if len(nums) == 0:
            return [-1, -1]
        l = self.searchleft(nums, target)
        r = self.searchright(nums, target)
        return [l, r]

    def searchleft(self, nums, target):
        left, right = 0, len(nums) - 1
        while (left <= right):
            mid = left + (right - left)//2
            if (nums[mid] < target):
                left = mid + 1
            elif (nums[mid] > target):
                right = mid - 1
            else:
                right = mid - 1
        
        if left == len(nums) or nums[left] != target:
            return -1
        else:
            return left
    
    def searchright(self, nums, target):
        left, right = 0, len(nums) - 1
        while (left <= right):
            mid = left + (right - left)//2
            if (nums[mid] < target):
                left = mid + 1
            elif (nums[mid] > target):
                right = mid - 1
            else:
                left = mid + 1
        
        if right == -1 or nums[right] != target:
            return -1
        else:
            return right

C++代码：注意数组越界的问题

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if (nums.size() == 0) return {-1, -1};
        int l = searchleft(nums, target);
        int r = searchright(nums, target);
        return {l, r};
    }
    int searchleft(vector<int>& nums, int target){
        int n = nums.size();
        int left = 0;
        int right = n-1;
        while (left <= right){
            int mid = left + (right - left)/2;
            if (nums[mid] < target){
                left = mid + 1;
            }
            else{
                right = mid - 1;
            }
        }
        if ((left == n) || (nums[left] != target)){
            return -1;
        }
        else{
            return left;
        }
    }
    int searchright(vector<int>& nums, int target){
        int n = nums.size();
        int left = 0;
        int right = n-1;
        while (left <= right){
            int mid = left + (right - left)/2;
            if (nums[mid] <= target){
                left = mid + 1;
            }
            else{
                right = mid - 1;
            }
        }
        if ((right == -1) || (nums[right] != target)){
            return -1;
        }
        else{
            return right;
        }
    }
};