【LeetCode-中等】34. 在排序数组中查找元素的第一个和最后一个位置 - 二分法

qmkn

已于 2024-02-28 17:44:43 修改

阅读量219

点赞数

分类专栏： LeetCode 文章标签：二分查找数组

于 2022-07-19 16:48:06 首次发布

本文链接：https://blog.csdn.net/qq_43619058/article/details/125874552

版权

LeetCode 专栏收录该内容

46 篇文章 0 订阅

订阅专栏

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

解法一：遍历

我的解法是先从左开始遍历数组，找到 nums 数组中第一个大于等于 target 的值，low为其下标。考虑到存在 nums = [2, 2]，target = 3 这样的情况，判断条件还需要加上 low < high，防止数组越界。

找到第一个大于等于 target 的值后，判断该值是否等于 target ，如不等于，则表示该数组中不存在 target 值，返回 [-1, -1]. 若存在则用同样的思路从数组的最右侧逐步向左寻找第一个 target 值，用 high 表示其下标，最终结果即为[low, high].

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result = {-1,-1};
        // nums为空
        if(nums.empty()) return result;
        int low = 0;
        int high = nums.size() - 1;
        // low < high : nums = [2, 2] target = 3
        while(nums[low] < target && low < high){
            low++;
        } 
        if(nums[low] != target) return result;
        while(nums[high] > target){
            high--;
        }
        result[0] = low;
        result[1] = high;
        return result;
    }
};

解法二：二分查找

这是力扣提供的题解，该题解充分利用了 nums 数组非递减排序的特点，采用二分查找的方法解决问题。

因为整个数组是非递减排序，可以使用二分法寻找第一个等于（或大于） target 的位置 leftIdx 和 第一个大于 target 的位置减一 rightIdx

由于 nums 数组中可能不存在 target ，因此得到的两个下标 leftIdx 和 rightIdx 进行校验，看是否符合条件，如果符合条件就返回 [leftIdx, rightIdx]，否则返回 [-1,-1]。

class Solution { 
public:
	// 二分查找，若 lower 为 true，查找第一个大于等于 target 的下标，为 false 则查找第一个大于 target 的下标
    int binarySearch(vector<int>& nums, int target, bool lower) {
        int left = 0, right = (int)nums.size() - 1, ans = (int)nums.size();
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
	
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.size() && nums[leftIdx] == target && nums[rightIdx] == target) {
            return vector<int>{leftIdx, rightIdx};
        } 
        return vector<int>{-1, -1};
    }
};

力扣给出的题解是比较简洁的方式，不容易理解。下面将它拆分开进行理解。
在排序数组中查找元素target的第一个和最后一个位置，可能存在以下三种情况：

情况一：target在数组范围外的左边/右边，返回{-1, -1}
情况二：target在数组范围内,且数组中存在target，返回{左边界，右边界}
情况三：target在数组范围内,但数组中不存在target，返回{-1, -1}

接下来，分别寻找左边界和右边界，用两个函数分别表示，其中存在target ∈ [left, right] 和 target ∈ (left, right) （注释部分）两种解题思路，情况二中，前者需判断 left <= right，返回 {left, right}，后者则需判断right - left > 1即left + 1 <= right - 1，返回 {left + 1, right - 1}。

寻找左边界：

	//找左边界
    int getLeftBorder(vector<int>& nums, int target){
        int left = 0, right = nums.size() - 1;
        int leftBorder  = -1;
        //-2表示leftBorder未被赋值，即情况一
        //不赋值为-1的原因:target是数组第一个数时,leftBorder也为-1,此时为情况2,应返回{0,r}而不是{-1,-1}
        //int leftBorder  = -2;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] >= target){
                right = mid - 1;
                if(nums[mid] == target){
                    leftBorder = mid;
                }
                //不包含target的左边界
                //leftBorder = right;
            }else{
                left = mid + 1;
            }
        }
        return leftBorder;
    }

寻找右边界：

    //找右边界
    int getRightBorder(vector<int>& nums, int target){
        int left = 0, right = nums.size() - 1;
        int rightBorder  = -1;
        //-2表示rightBorder未被赋值，即情况一;
        //int rightBorder  = -2;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid + 1;
                if(nums[mid] == target){
                    rightBorder = mid;
                }
                //不包含target的右边界
                //rightBorder = left;
            }
        }
        return rightBorder;
    }

对三种情况进行处理：

    vector<int> searchRange(vector<int>& nums, int target) {
        int left = getLeftBorder(nums, target);
        int right = getRightBorder(nums, target);
        //情况一: target在数组范围外的左边/右边,返回{-1, -1}
        if(left == -1 || right == -1) return {-1, -1};
        //if(left == -2 || right == -2) return {-1, -1};
        //情况二: target在数组范围内,且数组中存在target,返回{左边界，右边界}
        if(left <= right) return {left, right};
        //情况二 不包含target的左,右边界 right与left之间至少有一个target存在
        //if(right - left > 1) return {left + 1, right - 1};
        //情况三: target在数组范围内,但数组中不存在target,返回{-1, -1}
        return {-1,-1};
    }

全部代码如下：

class Solution {
public:
    //找左边界
    int getLeftBorder(vector<int>& nums, int target){
        int left = 0, right = nums.size() - 1;
        int leftBorder  = -1;
        //-2表示leftBorder未被赋值，即情况一
        //不赋值为-1的原因:target是数组第一个数时,leftBorder也为-1,此时为情况2,应返回{0,r}而不是{-1,-1}
        //int leftBorder  = -2;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] >= target){
                right = mid - 1;
                if(nums[mid] == target){
                    leftBorder = mid;
                }
                //不包含target的左边界
                //leftBorder = right;
            }else{
                left = mid + 1;
            }
        }
        return leftBorder;
    }
    //找右边界
    int getRightBorder(vector<int>& nums, int target){
        int left = 0, right = nums.size() - 1;
        int rightBorder  = -1;
        //-2表示rightBorder未被赋值，即情况一;
        //int rightBorder  = -2;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid + 1;
                if(nums[mid] == target){
                    rightBorder = mid;
                }
                //不包含target的右边界
                //rightBorder = left;
            }
        }
        return rightBorder;
    }

    vector<int> searchRange(vector<int>& nums, int target) {
        int left = getLeftBorder(nums, target);
        int right = getRightBorder(nums, target);
        //情况一: target在数组范围外的左边/右边,返回{-1, -1}
        if(left == -1 || right == -1) return {-1, -1};
        //if(left == -2 || right == -2) return {-1, -1};
        //情况二: target在数组范围内,且数组中存在target,返回{左边界，右边界}
        if(left <= right) return {left, right};
        //情况二 不包含target的左,右边界 right与left之间至少有一个target存在
        //if(right - left > 1) return {left + 1, right - 1};
        //情况三: target在数组范围内,但数组中不存在target,返回{-1, -1}
        return {-1,-1};
    }
};