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

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

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

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

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 0 <= nums.length <= 105

• 109 <= nums[i] <= 109

• nums 是一个非递减数组

• 109 <= target <= 109

思路分析

最基本的二分查找法 704. 二分查找，是在升序排列的数组中查找元素，找到了就返回，找不到就返回-1。所谓的找到就是target == nums[mid]。

本题目是要查找元素出现的第一个和最后一个位置。

1. 查找元素出现的第一个位置：
   • 当target == nums[mid] 时，不能立即返回，要缩小右半区间，看左半区间是否还存在要查找的元素。
   • 当target > nums[mid] 时， 说明target还在mid右侧，第一个target也在mid右侧，所以缩小左边界。
   • 当target < nums[mid] 时， 说明target还在mid左侧，应该缩小右边界。
2. 查找元素出现的最后一个位置：
   • 当target < nums[mid]， 缩小右边界。
   • 当target == nums[mid]，不能立即返回，缩小左边界，在右半部分继续查找元素。
   • 当target > nums[mid]，缩小左边界。

规定：使用左闭右闭区间[left, right]

一、查找元素在排序数组的第一个位置

问题一：在查找元素在排序数组中的第一个位置时，如果元素存在，那么最后返回的是left还是right？

**返回left。**由于是在闭区间[left, right]中查找第一个位置，当target == nums[mid] 的时候，这时找到的可能就是第一个元素。但是，为了确认左半区间还没有该元素，就会把right的值设为mid - 1，那么当左半部分查找不到该元素的时候，left最终的值就会是之前mid的值。

问题二：在查找元素在排序数组中的第一个位置时，怎么确定元素不存在呢？

当要查找的元素大于排序数组中所有元素时（即元素在数组右边界外）

比如，要在排序数组{5, 7, 7, 8, 8, 10}中查找目标元素target=15，这时target=15大于数组中所有的元素，那么查找结束时right=nums.length-1，left=nums.length，即left超出了数组nums的最大索引nums.lenght-1。由于上面已经确定最终返回left，因此在这种情况下元素不存在的条件是left==nums.length。

当要查找的元素小于排序数组中所有元素时（即元素在左边界外）

比如，要在排序数组{5, 7, 7, 8, 8, 10}中查找目标元素target=2，这时target = 2小于数组中所有的元素，那么在查找结束时right = -1， left = 0。这时元素不存在的条件 nums[left]!=target。

当要查找的元素大于排序数组中最小元素，小于排序数组中最大元素时（即元素在区间范围内）

比如，要在排序数组{5, 7, 7, 8, 8, 10}中查找目标元素target=9，这时target=9虽然在排序数组中不存在，但其大于数组中最小元素，小于数组中最大元素。因此，查找结束时left=5和right=4。也就是说在这种情况下，当目标元素在数组中不存在时，left的值是在区间[0，nums.lenght-1]内的。同样的，这时元素不存在的条件是nums[left]!=target。

**综上所述：**在左闭右闭区间[left, right]内查找元素的第一个位置时，如果目标元素存在，返回left；元素不存在的判断条件是 一是left==nums.length，二是nums[left]!=target。

Demo

int getleftposition(vector<int>& nums, int target) {
    //规定：左闭右闭区间 
    int left = 0, right = nums.size() - 1; 
    while(left <= right) {
        int mid = left + ((right - left) >> 1);
          if(target > nums[mid]) {
              //target在mid值右侧，缩小左半区间
              left = mid + 1;
           } else if (target < nums[mid]) {
              right = mid - 1;
           } else {
              // target == nums[mid]
              // 缩小右半区间，在左半区间继续寻找是否存在target
              right = mid - 1;
           }
     }

     if(left == nums.size() || nums[left] != target)
         return -1;
        
     return left;
}   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

问题一：在查找元素在排序数组中的最后一个位置时，如果元素存在，那么最后是返回left还是right呢？

**返回right。**由于是在闭区间[left,right]中查找最后一个位置，那么当target==nums[mid]时，这时找到的可能就是最后一个元素。但是，为了确认右半部分还有没有该元素，会将left的值设置为mid+1，此时由于数组是升序排列的，那么当右半部分查找不到该元素时，right最终的值就会是之前mid的值。

问题二：在查找元素在排序数组中的最后一个位置时，怎么确定元素不存在呢？

当要查找的元素大于排序数组中所有元素时（即元素在数组右边界外）

比如，要在排序数组{5, 7, 7, 8, 8, 10}中查找目标元素target=15，这时target=15大于数组中所有的元素，那么查找结束时right=nums.length-1，left=nums.length。由于上面已经确定最终返回right，因此在这种情况下元素不存在的条件是nums[right]!=target。

当要查找的元素小于排序数组中所有元素时（即元素在左边界外）

比如，要在排序数组{5, 7, 7, 8, 8, 10}中查找目标元素target=-2，这时target=-2小于数组中所有的元素，那么查找结束时right=-1，left=0。同样的，由于上面已经确定最终返回right，因此在这种情况下元素不存在的条件是right==-1。

当要查找的元素大于排序数组中最小元素，小于排序数组中最大元素时

比如，要在排序数组{5, 7, 7, 8, 8, 10}中查找目标元素target=9，这时target=9虽然在排序数组中不存在，但其大于数组中最小元素，小于数组中最大元素。因此，查找结束时left=5和right=4。也就是说在这种情况下，当目标元素在数组中不存在时，right的值是在区间[0，nums.lenght-1]内的。此时，元素不存在的条件是nums[right]!=target。

根据上述分析，我们确定了在左闭右闭的区间[left,right]内查找元素的最后一个位置时，如果目标元素存在，则返回right；元素不存在的判断条件一是right==-1，二是nums[right]!=target。

Demo

int getrightposition(vector<int>& nums, int target) {
    int left = 0, right = nums.size() - 1;
    while(left <= right) {
        int mid = left + ((right - left) >> 1);
        if(target < nums[mid]) {
            right = mid - 1;
        } else if (target == nums[mid]) {
            // 往右边区间继续找是不是最后一个target
            left = mid + 1;
         } else {
            // target > nums[mid]
            left = mid + 1;
        }
    }

    if(right == - 1 || nums[right] != target) {
        return -1;
    }

    return right;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

C++ 题解

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> ans(2, -1);
        ans[0] = getleftposition(nums, target);
        ans[1] = getrightposition(nums, target);
        return ans;
    }

private:
    int getleftposition(vector<int>& nums, int target) {
        //规定：左闭右闭区间 
        int left = 0, right = nums.size() - 1; 
        while(left <= right) {
            int mid = left + ((right - left) >> 1);
            if(target > nums[mid]) {
                //target在mid值右侧，缩小左半区间
                left = mid + 1;
            } else if (target < nums[mid]) {
                right = mid - 1;
            } else {
                // target == nums[mid]
                // 缩小右半区间，在左半区间继续寻找是否存在target
                right = mid - 1;
            }
        }

        if(left == nums.size() || nums[left] != target)
            return -1;
        
        return left;
    }   

    int getrightposition(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while(left <= right) {
            int mid = left + ((right - left) >> 1);
            if(target < nums[mid]) {
                right = mid - 1;
            } else if (target == nums[mid]) {
                // 往右边区间继续找是不是最后一个target
                left = mid + 1;
            } else {
                // target > nums[mid]
                left = mid + 1;
            }
        }

        if(right == - 1 || nums[right] != target) {
            return -1;
        }

        return right;
    } 
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

时间复杂度：O (log n)

空间复杂度: O (1)