力扣 34. 在排序数组中查找元素的第一个和最后一个位置 （每日一题）

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
进阶：
你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

提示：
0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109

有序数组查找一个数，可以用二分解决；

第一个方法是直接遍历：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
           int l=nums.size();
           int flag=0;
           int st,ed;
           if(nums.size()==1){
               if(nums[0]==target){
                   return {0,0};
               }
              else  if(nums[0]!=target){
                   return {-1,-1};
               }
           }
           for(int i=0;i<l;i++){
               if(flag==0&&nums[i]==target){
                    st=i;
                    flag=1;
               }
               if(flag==1){
                   if(nums[i]!=target)
                   {
                       ed=i-1;
                       flag=2;
                       break;
                   }
               }
           }
           if(flag==1)
           {
              ed=l-1;
           }
           if(flag==0){
               return {-1,-1};
           }
           return {st,ed};
    }
};

第二个方法是二分找到等于target的位置，然后向两端遍历：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.empty()){
            return {-1,-1};
        }
         int l=0;
         int r=nums.size()-1;
         int k=-1;
         while(l<=r){
            int mid=(l+r)/2;
            if(target==nums[mid]){
                 k=mid;
                break;
            }
            else if(nums[mid]>target){
                r=mid-1;
            }
            else if(nums[mid]<target){
                  l=mid+1;
            }
         }
         if(k==-1){
             return {-1,-1};
         }
         int st=0,ed=nums.size()-1;
         for(int i=k;i>=0;i--){
               if(nums[i]!=target){
                   st=i+1;
                   break;
               }
         } 
         for(int i=k;i<nums.size();i++){
                if(nums[i]!=target){
                    ed=i-1;
                    break;
                }
         }
         return {st,ed};
    }
};

第三个方法是题解区wei哥的方法，二分找到起点和终点：

#include <iostream>
#include <vector>
using namespace std;
class Solution {
private:
    int First(vector<int>& num1,int target1){
        int r=num1.size()-1;
        int l=0;
        while(l<r){
            int mid=l+(r-l)/2;
            if(num1[mid]==target1){
                r=mid;
            }
            else if(num1[mid]<target1){
                l=mid+1;
            }
            else if(num1[mid]>target1){
                r=mid-1;
            }
        }
        if(num1[l]!=target1){
            return -1;
        }
        return l;
    }
    int End(vector<int>& num2,int target2){
        int r=num2.size()-1;
        int l=0;
        while(l<r){
            int mid=l+(r-l+1)/2;
            if(num2[mid]==target2){
                l=mid;
            }
            else if(num2[mid]<target2){
                l=mid+1;
            }
            else if(num2[mid]>target2){
                r=mid-1;
            }
        }
        if(num2[l]!=target2){
            return -1;
        }
        return l;
    }
public:
    vector<int> searchRange(vector<int>& nums, int target) {
            if(nums.empty()){
                return {-1,-1};
            }
            int first=First(nums,target);
            if(first==-1){
                return {-1,-1};
            }
            int end=End(nums,target);
            return {first,end};
    }
};