34. Find First and Last Position of Element in Sorted Array

Given an array of integers nums 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].

Example 1:

Input: nums = [5,7,7,8,8,10], target = 8
Output: [3,4]

Example 2:

Input: nums = [5,7,7,8,8,10], target = 6
Output: [-1,-1]

Solution

Approach 1: Binary search.

Code (Python)

Approach 1:

class Solution:
    def searchRange(self, nums, target):
        if not nums or target < nums[0] or target > nums[-1]:
            return [-1, -1]

        # implementing python's bisect.bisect_left()
        low = self._bisect_left(nums, target)
        if low < len(nums) and nums[low] == target:
            return [low, self._bisect_left(nums, target + 1) - 1]
        return [-1, -1]

    def _bisect_left(self, nums, target):
        # return the index that target would be able to insert into. if there are existing targets, return the leftmost position.
        start, end = 0, len(nums) # SPECIAL NOTE: len(nums) is also valid -- when target > nums[-1]
        while start < end: # pointers always move after an iteration so in the end, start == end is guaranteed
            mid = (start + end) // 2
            if nums[mid] >= target:
                end = mid
            else:
                start = mid + 1
        return start

Code (C++)

Approach 1:

class Solution {
private:
    int searchTarget(vector<int>& nums, int target) {
        int head = 0;
        int tail = nums.size() - 1;
        while (head <= tail)
        {
            int mid = head + (tail - head) / 2;
            if (target <= nums[mid])
                tail = mid - 1;
            else
                head = mid + 1;
        }
        return head;
    }
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> targetRange;
        int head = -1;
        int tail = -1;
        if (nums.size() > 0)
        {
            head = searchTarget(nums, target);
            if (head >= nums.size() || nums[head] != target)
                head = -1;
            tail = searchTarget(nums, target + 1) - 1;
            if (tail < 0 || nums[tail] != target)
                tail = -1;
        }
        targetRange.push_back(head);
        targetRange.push_back(tail);
        return targetRange;
    }
};