LeetCode | 34. 查找元素位置

题：力扣

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

给你一个按照非递减顺序排列的整数数组 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

我的原始思路：

暴力搜索，创建两个vector，一个存[-1,-1]代表没有找到，一个是找到后收集数组位置。

判断收集到的数组大小，若只有1个，需要复制里面的内容，得到结束位置。

若大于2，则需要删除中间的数据，只保留头和尾。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        //暴力解法最清晰，但是时间复杂度为O(n)不符合要求的O（log n）
        bool have = false;
        int position;
        vector<int> result;
        vector<int> result_none;
        result_none.push_back(-1);
        result_none.push_back(-1);
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == target) {
                result.push_back(i);
                have = true;
            }
        }
        if (have == true) {
            if( result.size() == 1) {
                result.push_back(result[0]);
            }
            if( result.size() > 2) {
                int a = result.front();
                int b = result.back();  
                result.clear();              
                result.push_back(a);
                result.push_back(b);
            }

            return result;
        }
        else {
            return  result_none;
        }
    }
};

 其他思路：

时间复杂度要求O(logn),采用二分大法

之前的二分法找到就停止了，因为数组中没有重复的元素。现在数组中有重复，且要找到元素的边界。

最重要的是处理nums[middle]==target的情况，一个往左走，找左边界，一个往右走，找右边界。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {

        int leftBorder = findLeft(nums, target);
        int rightBorder = findRight(nums, target);
        vector<int> result1;
        result1.push_back(-1);
        result1.push_back(-1);
        // 情况一
        if (leftBorder == -2 || rightBorder == -2) {
            return  result1;
        } 
        // 情况三
        if (rightBorder - leftBorder > 1) {
            vector<int> result;
            result.push_back(leftBorder + 1);
            result.push_back(rightBorder - 1);
            return result;
        }
        // 情况二
        return result1;
        
        
    }

    int findRight(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int middle = (left + right) / 2;
        int rightBorder = -2;

        //target小于最左边，没找到，那么left一直不更新]
        while (left <= right) {
            if (nums[middle] == target) {
                left = middle + 1; //找到了也往右走，看右边还有没有，找右边界
                rightBorder = left;
              
            }
            else if (nums[middle] < target) { //在右边
                left = middle + 1;
                rightBorder = left;
               
            }
            else {
                right = middle - 1;
               
            }
            middle = (left + right) / 2;

        }
       
        return rightBorder; //右边界=left-1
        

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

        //target大于最右边，没找到，那么right一直不更新
        while (left <= right) {
            if (nums[middle] == target) {
                right = middle - 1; //找到了也往左走，看左边还有没有，找左边界
                leftBorder = right;
            }
            else if (nums[middle] < target) { //在右边
                left = middle + 1;

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

            }
            middle = (left + right) / 2;
        }
       
        return  leftBorder;  //左边界
        
       
    }

};

——————

浅谈则止，细致入微AI大道理

扫描下方“AI大道理”，选择“关注”公众号

—————————————————————

​

—————————————————————