34在排序数组中查找元素的第一个和最后一个位置

---

title: 在排序数组中查找元素的第一个和最后一个位置
categories:

• leetcode

---

在排序数组中查找元素的第一个和最后一个位置

题目

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

思路

与二分查找要求的条件（有序、无重复）不同的是，该题并没有说无重复元素。

寻找target在数组里的左右边界，有如下三种情况：

• 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
• 情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
• 情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}

为了让代码清晰，我分别写两个二分来寻找左边界和右边界

寻找右边界

确定好：计算出来的右边界是不包含target的右边界，左边界同理。

// 二分查找，寻找target的右边界（不包括target）
// 如果rightBorder为没有被赋值（即target在数组范围的左边，例如数组[3,3]，target为2），为了处理情况一
int getRightBorder(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
    int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
    while (left <= right) { // 当left==right，区间[left, right]依然有效
        int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
        if (nums[middle] > target) {
            right = middle - 1; // target 在左区间，所以[left, middle - 1]
        } else { // 当nums[middle] == target的时候，更新left，这样才能得到target的右边界
            left = middle + 1;
            rightBorder = left;
        }
    }
    return rightBorder;
}

代码

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftBorder = getLeftBorder(nums, target);
        int rightBorder = getRightBorder(nums, target);

        if (leftBorder == -2 || rightBorder == -2) return {-1, -1};

        if (rightBorder - leftBorder > 1) return {leftBorder+1, rightBorder-1};

        return {-1,-1};
    }
private:
    int getRightBorder(vector<int>& nums, int target){
       int left = 0;
       int right = nums.size() -1;
       int rightborder = -2;
       while(left<=right){
           int mid = left + (right-left)/2 ;
           if(nums[mid]>target){
               right = mid -1;
           }
           else{
                left = mid + 1;
                rightborder = left;              
           }
       }
       return rightborder;

    }
    int getLeftBorder(vector<int>& nums, int target){
       int left = 0;
       int right = nums.size() -1;
       int leftBorder = -2;

        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int mid = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if(nums[mid] < target){
               left = mid + 1;

            }
            else{
                right = mid - 1;
                leftBorder = right;
            }
        }

       return leftBorder;
    }
};