[Leetcode 89] 34 Search for a Range

Problem:

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].

 

Analysis:

The basic idea is first search for the existence of the target value. If not found, then just return {-1, -1}; If we found one in the given array, then we need to further search for whether there is same element preceeding it and sucseeding it. This procedure is recursive. Until we cannot further find element in the left subpart or right subpart, the result then is correct.

 

Code:

class Solution {
public:
    vector<int> searchRange(int A[], int n, int target) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<int> res;
        int s = 0, e = n-1, l = -1, r = -1;
        
        while (s <= e) {
            int m = (s + e) / 2;
            
            if (A[m] == target) {
                l = r = m;
                int old_l, old_r;
                while (l != -1) {
                    old_l = l;
                    l = search(A, s, l-1, target);
                }
                    
                while (r != -1) {
                    old_r = r;
                    r = search(A, r+1, e, target);
                }
                
                l = old_l;
                r = old_r;
                break;
            } else  if (A[m] > target)
                e = m-1;
            else
                s = m+1;
        }
        
        res.push_back(l);
        res.push_back(r);
        
        return res;
    }
    
private:
    int search(int A[], int s, int e, int t) {
        while (s <= e) {
            int m = (s+e) / 2;
            
            if (A[m] == t) {
                return m;
            } else if (A[m] > t)
                e = m - 1;
            else
                s = m + 1;
        }
        
        return -1;
    }
};