leetcode #34 在排序数组中查找元素的第一个和最后一个位置 | 刷题之路第一站——数组类相关问题

题号 34

题目描述

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

你的算法时间复杂度必须是 O(log n) 级别。

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

示例 1:

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

示例 2:

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

链接：leetcode #34 在排序数组中查找元素的第一个和最后一个位置

以下四种解题思路中，符合题目要求 O(logn) 时间复杂度的为思路3，可忽略1、2。 : >

解题思路1【顺序查找】：

从前往后依次比较数组中各元素值与目标值是否相等：
（1）当第一次遇到与目标值相等的元素时，记录下该元素的位置，为first；
（2）当最后一次遇到与目标值相等的元素时，再记录下此元素的位置，为last；
（3）如果数组中存在与目标值相等的元素，则输出first和last的值；否则直接输出 [-1，-1]。
时间复杂度： 最坏情况下，时间复杂度为O(n)
虽然这种思路通过了leetcode的提交，但是显然不满足题目中 O(logn) 的时间复杂度。

因为二分查找的时间复杂度为O(logn），符合题目中要求的时间复杂度，因此考虑使用二分查找法来解决问题。

解题思路2【二分查找+顺序查找】：

1- 采用二分查找法找到数组中与目标值相同的一个元素，记录下该元素的位置，为p；
2- 首先令 i = p，由 p 位置向前进行遍历，如果该位置的前一个元素与目标值相等，则将 i - 1，直至 i 指向数组中第一个元素；如果该位置的前一个元素与目标值不相等，则直接跳出此次循环；
3- 同理令 j = p，由p位置向后进行遍历，如果该位置的后一个元素与目标值相等，则将 j + 1，直至 j 指向数组中最后一个元素；如果该位置的后一个元素与目标值不相等，则直接跳出此次循环。
4- 如果数组中存在与目标值相等的元素，则输出 i 和 j 的值；否则直接输出 [-1，-1]。
时间复杂度： 虽然二分查找的时间复杂度为O(logn)，但是对重复元素的首末位置确定的时间复杂度为O(n)。所以最坏情况下，整体时间复杂度仍为O(n)。

虽然这种思路通过了leetcode的提交，但是仍然不满足题目中 O(logn) 的时间复杂度。

代码实现：

class Solution {
public:
	vector<int> searchRange(vector<int>& nums, int target) {
		int min = 0, max = nums.size() - 1;    //设定两个指针，初始状态下分别指向首尾元素
		int mid = 0;    //用于指向min和max的中间元素
		int p = -1;     //用于记录数组中与目标值相等的元素的位置
		while (min <= max)    //利用二分查找法找到一个与目标值相等的元素
		{
			mid = (min + max) / 2;
			if (nums[mid]==target)
			{
				p = mid;
				break;
			}
			if (nums[mid] > target)
				max = mid - 1;
			else if (nums[mid] < target)
				min = mid + 1;
		}
		if (p != -1)    //如果找到了与目标值相等的元素，则由该元素位置分别向前、向后探寻左右边界
		{
			int i = p, j = p;
			while (i)
			{
				if (nums[i - 1] != target)
					break;
				i--;
			}
			while (j < nums.size() - 1)
			{
				if (nums[j + 1] != target)
					break;
				j++;
			}
			return { i,j };
		}
		else
			return { -1,-1 };
	}
};

解题思路3【二分查找】：

思路参考：labuladong
备注：上方链接中，作者对二分查找的细节问题进行了详尽的分析和总结，对于二分查找问题的掌握非常具有参考价值

本问题等价于 在一个含有重复元素的、非降序排列的数组中找到给定目标值的左侧边界和右侧边界问题，因此需要对基本的二分查询方法进行修改。
1- 设定两个指针 left、right，初始状态下，left指向数组中第一个元素，right指向数组中最后一个元素；

2- 寻找目标值的左侧边界：
　当 left <= right 时 进行如下的循环：
　（1）指针 mid 指向 left 和 right 的中间元素；
　（2）如果 mid 所指元素等于 target，则令 right = mid - 1；
　【因为我们需要找到 target 的最左侧索引，所以当二者相等时，不是返回 mid 值，而是收紧右侧边界从而可以锁定左侧边界】
　（3）如果 mid 所指元素小于 target，则令 left = mid + 1；
　（4）如果 mid 所指元素大于 target，则令 right = mid -1 ；
　循环结束后，如果 left 所指元素等于 target 的值，则表明给定数组中存在该目标值，并且 left 为该目标值的左侧边界；如果 left 所指元素不等于 target 的值 或者 left 指向最后一个元素的后方，则表明数组中不存在该目标值。
　【不存在目标值的两种情况：a. 如果 target 大于数组中的所有元素，则 left 会指向最后一个元素的候方；b. 如果 target 小于数组中的最大元素，则 left 最终所指元素不等于 target 值。】
　
3- 寻找目标值的右侧边界：
　当 left <= right 时 进行如下的循环
　（1）指针 mid 指向 left 和 right 的中间元素；
　（2）如果 mid 所指元素等于 target，则令 left = mid +1;
　【因为我们需要找到 target 的最右侧索引，所以当二者相等时，不是返回 mid 值，而是收紧左侧边界从而可以锁定右侧边界】
　（3）如果 mid 所指元素小于 target，则令 left = mid + 1；
　（4）如果 mid 所指元素大于 target，则令 right = mid -1；
　循环结束后，如果 right 所指元素等于 target 的值，则表明给定数组中存在该目标值，并且 right 为该目标值的右侧边界，如果 right 所指元素不等于 target 的值 或者 right 指向第一个元素的前方，则表明数组中不存在该目标值。

4- 按查找结果进行输出即可。
　
时间复杂度： 相当于是两个独立的二分查找，所以时间复杂度为O(logn)。

代码实现：

class Solution {
public:
	vector<int> searchRange(vector<int>& nums, int target) {
		int left = 0, right = nums.size() - 1;    //设定两个指针，初始分别指向首尾元素
		vector<int> ans;    //用于存放结果数组
		
		//确定左侧边界
		while (left <= right)    
		{
			int mid = left + (right - left) / 2;    //令 mid 指向中间元素
			if (nums[mid] == target)    //如果 mid 所指元素等于目标值，则收缩右侧边界
				right = mid - 1;
			else if (nums[mid] < target) 
				left = mid + 1;
			else if (nums[mid] > target)
				right = mid - 1;
		}
		if (left == nums.size())    //如果 left 指向最后一元素的后方，则表明数组中不存在目标值
			left = -1;
		else
			left = nums[left] == target ? left : -1;    //如果 left 所指元素与目标值相同，则left为左侧边界；若不相等，则数组中不存在该目标值
		ans.push_back(left);

		left = 0;    //将 left 和 right 恢复到初始状态
		right = nums.size() - 1;

		//确定右侧边界
		while (left <= right)
		{
			int mid = left + (right - left) / 2;
			if (nums[mid] == target)    //如果 mid 所指元素等于目标值，则收缩左侧边界
				left = mid + 1;
			else if (nums[mid] < target)
				left = mid + 1;
			else if (nums[mid] > target)
				right = mid - 1;
		}
		if (right < 0)    //如果 right 指向第一个元素的前方，则数组中不存在该目标值
			right = -1;
		else 
			right = nums[right] == target ? right : -1;    //根据right所指元素与目标值是否相同，返回不同的结果
		ans.push_back(right);
		return ans;
	}
};