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

Every day a Leetcode

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

解法1：二分查找

直观的思路肯定是从前往后遍历一遍。用两个变量记录第一次和最后一次遇见 target 的下标，但这个方法的时间复杂度为 O(n)，没有利用到数组升序排列的条件。

由于数组已经排序，因此整个数组是单调递增的，我们可以利用二分法来加速查找的过程。

这道题可以看作是自己实现 C++ 里的 lower_bound 和 upper_bound 函数。

这里我们尝试使用左闭右开的写法，当然左闭右闭也可以。

代码：

/*
 * @lc app=leetcode.cn id=34 lang=cpp
 *
 * [34] 在排序数组中查找元素的第一个和最后一个位置
 */

// @lc code=start
class Solution
{
private:
    // 辅函数
    int lower_bound(vector<int> &nums, int target)
    {
        int n = nums.size();
        int left = 0, right = n;
        while (left < right)
        {
            int mid = left + (right - left) / 2;
            if (nums[mid] >= target)
                right = mid;
            else
                left = mid + 1;
        }
        return left;
    }
    // 辅函数
    int upper_bound(vector<int> &nums, int target)
    {
        int n = nums.size();
        int left = 0, right = n;
        while (left < right)
        {
            int mid = left + (right - left) / 2;
            if (nums[mid] > target)
                right = mid;
            else
                left = mid + 1;
        }
        return left;
    }

public:
    // 主函数
    vector<int> searchRange(vector<int> &nums, int target)
    {
        if (nums.empty())
            return vector<int>{-1, -1};
        int lower = lower_bound(nums, target);
        int upper = upper_bound(nums, target) - 1; // 这里需要减1位
        if (lower == nums.size() || nums[lower] != target)
            return vector<int>{-1, -1};
        return vector<int>{lower, upper};
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(logn) ，其中 n 为数组的长度。二分查找的时间复杂度为 O(logn)，一共会执行两次，因此总时间复杂度为 O(logn)。

空间复杂度：O(1) 。只需要常数空间存放若干变量。

拓展：二分查找的 3 种写法

2024.1.31 更新。

左闭右闭区间

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

左闭右开区间

int lower_bound(vector<int> &nums, int target)
{
	int n = nums.size();
	int left = 0, right = n;
	while (left < right)
	{
		int mid = left + (right - left) / 2;
		if (nums[mid] >= target)
			right = mid;
		else
			left = mid + 1;
	}
	return left; // right 也行
}

左开右开区间

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