Search for a Range——稍微升级版的二分查找

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,
Given [5, 7, 7, 8, 8, 10] and target value 8,
return [3, 4].

网上看到的思路更好，网上说的是，先用二分法找到左端点，再用二分搜索找到右端点。问题即得到解决。

我的思路不太好，我是首先找到等于target的索引（即以前用烂了的二分查找），然后以此为中心向两边扩。

1：我的方法：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int len=nums.size();
        int l=,r=len-;
        int mid;
        vector<int>res;
        int flag=;
        while(l<=r)
        {
            mid=l+(r-l)/;
            if(nums[mid]<target)
                l=mid+;
            else if(nums[mid]>target)
                r=mid-;
            else
            {
                flag=;
                break;
            }
        }
        if(flag==)
        {
             res.push_back(-);
             res.push_back(-);
        }
        else
        {
            l=mid;
            r=mid;
            while(l>=&&nums[l]==target)
            {
                if(nums[l]==target)
                l--;
            }
            while(r<=len-&&nums[r]==target)
            {
                if(nums[r]==target)
                r++;
            }

             res.push_back(l+);
             res.push_back(r-);
        }
       return res;
    }
};

2：网上看到直接二分查找左右端点的方法：

class Solution {
public:
    int begin = -, end = -;
    vector<int> searchRange(int A[], int n, int target) {
       vector<int>ans;
       find(A,,n-,target);
       ans.push_back(begin);
       ans.push_back(end);
       return ans;
    }
    void find(int A[], int l, int r, int target){
      if(l > r) return ;
      int mid = (l+r) >> ;
      if(A[mid] == target){
        if(begin == - || begin > mid)
          begin = mid;
        end = max(mid, end);
        find(A,l,mid-,target);
        find(A,mid+,r,target);
      }
      else if(A[mid] < target)
        find(A,mid+,r,target);
      else
        find(A,l,mid-,target);
    }
};

3：直接用 C++ STL 的 lower_bound 和 upper_bound 偷懒。

  class Solution {
    public:
        vector<int> searchRange(int A[], int n, int target) {
            int* lower = lower_bound(A, A + n, target);
            int* upper = upper_bound(A, A + n, target);
            if (*lower != target)
                return vector<int> {-, -};
            else
                return vector<int>{lower - A, upper - A - };
        }
    };