范围查找

Search for a Range

• 题目来源：
  leetcode 34

线性算法

利用第二种思路编写代码如下：

vector<int> searchRange(vector<int>& nums, int target) {

    vector<int> ans;

    if (nums.size()==0) {   //如果为空返回［－1,－1］
        ans.push_back(-1);
        ans.push_back(-1);
        return ans;
    }
    else{
        int start = 0;
        int end = nums.size()-1;
        int mid;
        int pos=-1;
        while (start<=end) {
            mid = (start+end)/2;
            if (nums[mid]==target) {
                pos = mid;            //找到位置时则纪录位置为pos，并终止循环
                break;
            }
            else if(nums[mid]>target){
                end = mid-1;
            }
            else{
                start = mid+1;
            }
        }
        if (pos!=-1) {         //当找到了target位置时，分别向两边扩展查找
            int i=pos;
            while (nums[i]==target&&i>=0) {   //向左边界扩展；当找到nums[i]!=target或者到达左边界了，则停止
                i--;
            }
            int j=pos;
            while (nums[j]==target&&j<nums.size()) {  //向右边界扩展；当找到nums[i]!=target或者到达右边界了，则停止
                j++;
            }
            ans.push_back(i+1);
            ans.push_back(j-1);
            return ans;
        }
        else{
            ans.push_back(-1);
            ans.push_back(-1);
            return ans;
        }

    }

}

log(n)的算法

int findStart(vector<int>& nums, int target){  //寻找左边界

    if (nums.size()==0) {
        return -1;
    }
    else{
        int start = 0;
        int end = nums.size()-1;
        int mid;
        while (start<=end) {
            mid = (start+end)/2;
            if(nums[mid]==target){
                if (mid==0) {  //当mid为数组最左边时，则mid就是左边界
                    return mid;
                }
                else if(nums[mid-1]!=target)   //当nums[mid-1]!=target，则说明mid是左边界（mid-1不越界的情况下）
                    return mid;
                else
                    end=mid-1;
            }
            else if(nums[mid]<target){
                start=mid+1;
            }
            else
                end=mid-1;
        }
        return -1;
    }
}
int findEnd(vector<int>& nums, int target){   //寻找右边界

    if (nums.size()==0) {
        return -1;
    }
    else{
        int start = 0;
        int end = nums.size()-1;
        int mid;
        while (start<=end) {
            mid = (start+end)/2;
            if(nums[mid]==target){
                if (mid==nums.size()-1) {  //当mid为数组最右边时，则mid就是右边界
                    return mid;
                }
                else if(nums[mid+1]!=target)  //当nums[mid+1]!=target，则说明mid是右边界（mid+1不越界的情况下）
                    return mid;
                else
                    start=mid+1;
            }
            else if(nums[mid]<target){
                start=mid+1;
            }
            else
                end=mid-1;
        }
        return -1;
    }
}

vector<int> searchRange(vector<int>& nums, int target) {
    vector<int> ans;

    if (nums.size()==0) {
        ans.push_back(-1);
        ans.push_back(-1);
        return ans;
    }
    else{
        //分别寻找左右边界
        int start = findStart(nums, target);
        int end = findEnd(nums, target);
        ans.push_back(start);
        ans.push_back(end);
        return ans;
    }
}