leedcode34. 在排序数组中查找元素的第一个和最后一个位置c++（对于代码随想录解法的个人理解）

小word

已于 2022-07-01 14:30:20 修改

阅读量500

点赞数 1

分类专栏： leedcode 文章标签： leetcode

于 2022-07-01 14:27:36 首次发布

本文链接：https://blog.csdn.net/cheers___/article/details/125556684

版权

leedcode 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

刚刚接触算法题新手，仅作个人记录，如果有哪方面错误请及时指正，谢谢。

代码引自代码随想录

题目：

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

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

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

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

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

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

首先是菜鸟本人解法，暴力法，肯定不如二分法，但是比较好想。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;
        vector<int> result;
        while(left<=right)
        {
            if((nums[left]==target)&&(nums[right]==target))
            {
                result.push_back(left);
                result.push_back(right);
                return result;
            }
            else if(nums[left]!=target)
            {
                left++;
            }
            else if(nums[right]!=target)
            {
                right--;
            }
        }
        result.push_back(-1);
        result.push_back(-1);
        return result;
    }
};

经过查看解析和代码随想录的解析，对二分法有进一步的了解，分享一下我对于代码随想录的解法的一些思路，供刚学习算法不太明白二分法的同学参考，有任何问题都可以和我交流，不胜感激。

寻找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}

个人理解：leftBorder，rightBorder代表左右边界（数组下标），但是不包含最终结果，比如找到{1,2,3,3,5}，leftBorder=1，rightBorder=4。这两个边界值在情况三的时候会用来计算最终输出位置。

三种情况还是很好理解的，主要是如何去寻找左边界和右边界。

主函数代码：

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};
 }

1.二分法确定边界：

在二分法中，right选取的值为数组最后一个元素值（如下代码），这时left和right的就变成了左闭右闭状态的区间。因为是左闭右闭，所以是可以取到right的，循环中left<=right。在每一次循环中如果找不到元素，就要改变left，和right，因为是左闭右闭，左值是可以取到的，left=middle+1；右值同理right=middle-1。

还有一种就是左闭右开型的，初始化left=0，但是right=nums.size(),right值为数组的长度，right已经是越界状态，所以在循环中不能取到right（其实，相比左闭右闭right向右移了一位，但是取不到那一位，两种方法实际上取到的下标是一样的），这就导致在循环后，更新right位置时要多取一位，right=middle即可。

2.确定左边界代码的理解：

int getLeftBorder(vector<int>& nums, int target) 
 {
        int left = 0;
        int right = nums.size() - 1;
        int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
        while (left <= right) 
        {
            int middle = left + ((right - left) / 2);//取中间值，并且防止数值溢出
            //二分法寻找target
            if (nums[middle] > target) 
            { 
                right = middle - 1;//本题是选择左闭右闭
                
            }
            //寻找左边界，nums[middle] == target的时候更新right
            else if(nums[middle] == target)
            {
                //这个地方比较难懂，middle此时已经找到target了，此时左边界只可能在middle左边或者middle产生
            
                right=middle-1;
                //使用right去缩减搜索区间，如果middle前面没有target，那么就返回leftBorder
                //leftBorder只是边界，并不是target的位置
                leftBorder=right;
            } 
            else 
            {
                left = middle + 1;
            }
        }
        return leftBorder;
    }

3.确定右边界函数的理解：

int getRightBorder(vector<int>& nums, int target) 
     {
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
        while (left <= right) 
        {
            int middle = left + ((right - left) / 2);//防止数值溢出
            if (nums[middle] > target) 
            {
                right = middle - 1;
            } 
            else if(nums[middle] == target)
            { 
            //确定右边界时，移动left，middle左边元素不可能为右边界，middle是可能的右边界
            //右边界记录为middle+1，是为了情况三时候做出if条件判断，最后会分别加一和减一。
                left = middle + 1;
                rightBorder = left;
            }
            else
            {
                left=middle+1;
            }
        }
        return rightBorder;
    }

4.全部函数实现

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 getLeftBorder(vector<int>& nums, int target) 
 {
        int left = 0;
        int right = nums.size() - 1;
        int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
        while (left <= right) 
        {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) 
            { 
                right = middle - 1;
                
            }
            else if(nums[middle] == target)
            {
                right=middle-1;
                leftBorder=right;
            } 
            else 
            {
                left = middle + 1;
            }
        }
        return leftBorder;
    }
     int getRightBorder(vector<int>& nums, int target) 
     {
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
        while (left <= right) 
        {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) 
            {
                right = middle - 1;
            } 
            else if(nums[middle] == target)
            { 
                left = middle + 1;
                rightBorder = left;
            }
            else
            {
                left=middle+1;
            }
        }
        return rightBorder;
    }
   
};

感谢代码随想录的精彩答案，我会一直学习下去，大家一起努力把，第一次写博客有错误请指明，祝君安康！