C++ 解法, 执行用时: 22ms, 内存消耗: 3760KB, 提交时间: 2022-07-24

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> searchRange(vector<int>& nums, int target) {
        // write code here
        int L=FindRightIndex(nums, target)+1;
        if(L==nums.size()||nums[L]!=target){
            return {-1,-1};
        }
        int R=FindRightIndex(nums, target+1);
        return {L,R};
    }
    //找到小于target最右侧的位置
    int FindRightIndex(vector<int>&nums,int target)
    {
          int left=0;
          int right=nums.size()-1;
          int ans=-1;
          while(left<=right)
          {
              int mid=(left+right)/2;
              if(nums[mid]<target){
                  left=mid+1;
                  ans=mid;
              }
              else
              {
                  right=mid-1;
              }
          }
        return ans;
    }
};

C++ 解法, 执行用时: 26ms, 内存消耗: 3780KB, 提交时间: 2022-07-28

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> searchRange(vector<int>& v, int target) {
        // write code here
        int n = v.size();
        vector<int>res(2,0);
        if(n==0) return {-1,-1};
        
        int l=0,r=n-1;
        while(l<r)
        {
            int m = (l+r)/2;
            if(v[m] >=target)
                r = m;
            else
                l = m+1;
        }
        if(v[l] !=target) return {-1,-1};
        res[0] = l;
        
         l = 0;
         r = n-1;
        while(l<r)
        {
            int m = l + (r-l)/2 +1;
           if(v[m] <=target)
               l = m;
            else//  v[m] > target
                r = m-1;
        }
        res[1] =l;
        return res;
    }
};

C++ 解法, 执行用时: 25ms, 内存消耗: 3772KB, 提交时间: 2022-02-24

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> searchRange(vector<int>& nums, int target) {
        int len = nums.size();
    vector<int> vt;
    if (len == 0)return { -1, -1 };
    int i = 0;
    for ( i; i < len; i++)
    {
        if (nums[i] == target)
        {
            vt.push_back(i);
            break;
        }
    }
    for (int j = len - 1; j >= i; j--)
    {
        if (nums[j] == target)
        {
            vt.push_back(j);
            break;
        }
    }
        if (vt.size() == 0)
        return{ -1, -1 };
    return vt;
    }
};

C++ 解法, 执行用时: 26ms, 内存消耗: 3652KB, 提交时间: 2022-07-25

class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型vector
     * @param target int整型
     * @return int整型vector
     */
    vector<int> searchRange(vector<int>& nums, int target) {
        // write code here
        vector<int> res(2, -1);
        int start = search(nums, target);
        if (nums[start] != target || nums.size() == start) return res;
        return {start, search(nums, target + 1) - 1};
    }
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return right;
    }
};

C++ 解法, 执行用时: 26ms, 内存消耗: 3668KB, 提交时间: 2022-05-26

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型vector
     * @param target int整型
     * @return int整型vector
     */
    vector<int> searchRange(vector<int>& nums, int target)
    {
    //     write code here
    //     
    //    
    //    vector<int> v(2, 0);

    //    int left = 0;
    //    int right = 0;

    //    int i = 0;
    //    for (i = 0; i < nums.size(); i++)
    //    {
    //        if (nums[i] == target)
    //        {
    //            left = i;
    //            break;
    //        }
    //    }


    //    if (i == nums.size())
    //    {
    //        v[0] = v[1] = -1;
    //        return v;
    //    }

    //    for (i = nums.size() - 1; i >= 0; i--)
    //    {
    //        if (nums[i] == target)
    //        {
    //            right = i;
    //            break;
    //        }
    //    }

    //    v[0] = left;
    //    v[1] = right;
    //    return v;

        int left = 0;
        int right = nums.size() - 1;

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

            if (nums[mid] < target)
            {
                left = mid + 1;
            }
            else
            {
                right = mid - 1;
            }
        }

        vector<int> v(2, 0);

        if (ret == -1)
        {
            v[0] = -1;
            v[1] = -1;
            return v;
        }
        else
        {
            left = ret;
            while (left >= 0 && nums[left] == target)
            {
                left--;
            }
            v[0] = left + 1;

            right = ret;

            while (right <= nums.size() - 1 && nums[right] == target)
            {
                right++;
            }
            v[1] = right - 1;
            return v;
        }

    }
};