【LeetCode】No.34 Search for a Range

【原题】

Given an array of integers sorted in ascending order, 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].

【翻译】

数字在排序数组中出现的次数。

给定一个排好序的数组和一个数字，输出该数字出现的起始位置和结束位置，以及出现的次数（即：结束位置-起始位置+1）。

【解题思路】

排好序的数组→二分查找。

改进的二分查找：

二分查找算法总是先拿数组中间的数字和k作比较。如果中间的数字比k大，那么k只有可能出现在数组的前半段，下一轮我们只在数组的前半段查找就可以了。如果中间的数字比k小，那么k只有可能出现在数组的后半段，下一轮我们只在数组的后半段查找就可以了。如果中间的数字和k相等呢？我们先判断这个数字是不是第一个k。如果位于中间数字的前面一个数字不是k，此时中间的数字刚好就是第一个k。如果中间数字的前面一个数字也是k，也就是说第一个k肯定在数组的前半段，下一轮我们仍然需要在数组的前半段查找。

二分法在数组中查找一个合乎要求的数字时间复杂度是O(logn)，因此总的时间复杂度也只有O(logn)。

==============================================================================================

伪代码1：找到开头的k

1、一旦发现start>end，就说明数组中根本没有K，所以返回-1表示出错；

2、计算中点位置，将中点的值和k进行比较：

2.1. 若k小于中点值，则在前半段找

2.2. 若k大于中点值，则在后半段找

2.3. 若k等于中点值：

a）若中点已经是数组第一个元素，则直接返回中点位置；

b）若中点值的前一个元素和中点值不同，则直接返回中点位置；

c）若中点值前一个元素和中点值相同，则继续在前半段找；

3、计算出新的start、end后继续递归。

伪代码2：主函数

1、健壮性判断：若数组为空、数组的第一个元素大于k、最后一个元素小于k，则根本不存在k，直接返回0.

2、分别计算k开头位置、结尾位置

3、只要其中一个为-1则返回-1；否则返回（结尾-开头+1）

===============================================================================================

（1）递归：每次的前半段、后半段有重复的操作，所以用递归，但是每次操作的数组范围不一样，所以应该再加两个参数传入start和end。

class Solution {
public:
    //找起始位置
    int GetFirstTarget(vector<int>& nums, int target, int start, int end){
        if(start > end){
            return -1;
        }
        int mid = (start+end)/2;
        //当nums[mid]=target，又分三种情况
        if(nums[mid] == target){
            if((mid>0 && nums[mid-1] != target) || mid == 0){//当mid不是第一个且左邻居不同（防止越界） 或者 mid就是数组第一个元素
                return mid;
            }
            else{//否则在前半段继续找第一次出现的位置
                end = mid-1;
            }
        }
        //当nums[mid]>target，在前半段找
        else if(nums[mid] > target){
            end = mid-1;
        }
        //当nums[mid]<target，在后半段找
        else{
            start = mid+1;
        }
        return GetFirstTarget(nums, target, start, end);//缩小要寻找的范围进行递归
    }
    
    //找结束位置
    int GetLastTarget(vector<int>& nums, int target, int start, int end){
        if(start > end){
            return -1;
        }
        int mid = (start+end)/2;
        //当nums[mid]=target，又分三种情况
        if(nums[mid] == target){
            if((mid<(nums.size()-1) && nums[mid+1] != target) || mid == nums.size()-1){//当mid不是最后一个且右邻居不同（防止越界） 或者 mid就是数组最后一个元素
                return mid;
            }
            else{//否则在后半段继续找最后一次出现的位置
                start = mid+1;
            }
        }
        //当nums[mid]>target，在前半段找
        else if(nums[mid] > target){
            end = mid-1;
        }
        //当nums[mid]<target，在后半段找
        else{
            start = mid+1;
        }
        return GetLastTarget(nums, target, start, end);//缩小要寻找的范围进行递归
    }
    
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result;
        if(nums.size() <= 0){
            result.push_back(-1);
            result.push_back(-1);
        }
        else{
            int firstNum = GetFirstTarget(nums, target, 0, nums.size()-1);
            int lastNum = GetLastTarget(nums, target, 0, nums.size()-1);
            result.push_back(firstNum);
            result.push_back(lastNum);
        }
        return result;
    }
};

（2）非递归：超时！

//找起始位置
    int GetFirstTarget(vector<int>& nums, int target, int start, int end){
        if(start > end){
            return -1;
        }
        int mid = (start+end)/2;
        while(start <= end){
            //当nums[mid]=target，又分三种情况
            if(nums[mid] == target){
                if((mid>0 && nums[mid-1] != target) || mid == 0){//当mid不是第一个且左邻居不同（防止越界） 或者 mid就是数组第一个元素
                    return mid;
                }
                else{//否则在前半段继续找第一次出现的位置
                    end = mid-1;
                }
            }
            //当nums[mid]>target，在前半段找
            else if(nums[mid] > target){
                end = mid-1;
            }
            //当nums[mid]<target，在后半段找
            else{
                start = mid+1;
            }
        }//while
    }

【O(n)的解法】

1、遍历一次，直接找，设置一个标记用来保证不移动start只移动end。可是时间为O(n)，不符合。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int start=-1, end = -1;
        for(int i=0; i<nums.size(); i++){
            if(nums[i]==target && start == -1){
                start = i;
                end = i;
            }
            else if(start != -1 && nums[i] == target){
                end += 1;
            }
        }
        vector<int> v;
        v.push_back(start);
        v.push_back(end);
        return v;
    }
};

2、若直接运用二分查找：给出的例子中，可以先用二分查找算法找到一个3。由于3可能出现多次，因此我们找到的3的左右两边可能都有3，于是在找到的3的左右两边顺序扫描，分别找出第一个3和最后一个3。因为要查找的数字在长度为n的数组中有可能出现O(n)次，所以顺序扫描的时间复杂度是O(n)。因此这种算法的效率和直接从头到尾顺序扫描整个数组统计3出现的次数的方法是一样的。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result;
        int low = 0, high = nums.size()-1;
        int mid;
        while(low <= high){
            mid = (low+high)/2;
            if(nums[mid] == target) break;
            else if(nums[mid] > target){ high = mid-1; }
            else { low = mid+1; }
        }//找不到跳出循环此时low>high，返回{-1，-1}；找到了也跳出循环此时要判断nums[mid]周围情况
        
        //往mid两边顺序扫描，直到找到起始位置和解释位置，最坏为O(n)
        if(low <= high){
            low = mid-1;//把low放在mid的左邻居，看nums[mid-1]等不等于target
            while(low >=0 && nums[low] == target){//条件1：如果mid=0是数组的第一个元素；条件2：mid左边也是target
                low--;
            }
            high = mid+1;
            while(high < nums.size() && nums[high] == target){//条件1：如果mid=nums.size()-1是数组的最后一个元素；条件2：mid右边也是target
                high++;
            }
            result.push_back(low + 1);
            result.push_back(high - 1);
        }
        else{
            result.push_back(-1);
            result.push_back(-1);
        }
        return result;
    }
};