LeetCode Search for a Range

class Solution {
private:
    int getDirection(int A[], int idx, int target, bool isDefaultBack) {
        int r = A[idx] - target;
        if (r == 0) {
            r = isDefaultBack ? -1 : 1;
        }
        return r;
    }   
    int getFirstValueIndex(int A[], int n, int target, bool isFromBack) {
        int p = -1; 
        int q = n;
        while (p + 1 < q) {
            int mid_idx = (p + q) / 2;
            int where = getDirection(A, mid_idx, target, isFromBack);
            if (where < 0) {
                p = mid_idx;
            } else {
                q = mid_idx;
            }
        }
        if (p != -1 && A[p] != target) {
            p = -1; 
        }
        if (q == n || A[q] != target) {
            q = -1; 
        }
        return isFromBack ? p : q;
    }   
public:
    vector<int> searchRange(int A[], int n, int target) {
        vector<int> res;
        res.push_back(getFirstValueIndex(A, n, target, false));
        res.push_back(getFirstValueIndex(A, n, target, true));
        return res;
    }   
};

进行两次二分查找，一次找upper bound一次找lower bound，如果线性查找的化就不符合要求了。

第二轮：

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

class Solution {
public:
    vector<int> searchRange(int A[], int n, int target) {
        vector<int> res(2, -1);
        if (A == NULL || n < 1 || target < A[0] || target > A[n-1]) {
            return res;
        }
        
        int lo = 0, hi = n-1;
        
        int st = lower_bound(A, A + n, target) - A;
        if (st >= n || A[st] != target) {
            return res;
        } 
        int ed = upper_bound(A, A + n, target) - A;
        res[0] = st;
        res[1] = ed-1;
        return res;
    }
};

 如果自己写lower_bound和upper_bound的话：

class Solution {
public:
    vector<int> searchRange(int A[], int n, int target) {
        vector<int> res(2, -1);
        if (A == NULL || n < 1 || target < A[0] || target > A[n-1]) {
            return res;
        }
        
        int lo = 0, hi = n;
        // lower_bound
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (A[mid] < target) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        
        if (A[lo] != target) {
            return res;
        }
        res[0] = lo;
        
        lo = 0, hi = n;
        // upper_bound
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (A[mid] <= target) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        res[1] = lo - 1;

        return res;
    }
};