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]

解题思想

有两个方法:

1. 第一个就是我想到的二分加暴力,比普通的暴力快点但不是完全的二分
   • 思想就是先用二分找到目标值的下标然后用暴力两边扩散
2. 第二个就是完全的二分法(快挺多的,可能这题在leetcode上的测试案例比较长)
   • 先用二分查找左下标,再用二分查找右下标. 复杂度是O(2log n),即等级为O(log n)

代码/第一个想法(二分+暴力):

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
	vector<int> re{ -1,-1 };
	int leftindex = 0;
	int rightindex = 0;
	//寻找符合的index位置
	int left = 0;
	int right = nums.size() - 1;
	int index;
	bool isTrue = false;

	while (left <= right)
	{
		index = (left + right) / 2;
		if (nums[index] == target)
		{
			isTrue = true;
			break;
		}
		if (nums[index] < target)
			left = index + 1;
		if (nums[index] > target)
			right = index - 1;
	}
	//判断是否找到
	if (isTrue)
	{
		leftindex = index;
		rightindex = index;

		for (int i = index; i >= 0; i--)        //向左边扩散
		{
			if (nums[leftindex] == target)
			{
				leftindex--;
				continue;
			}
			break;
		}
		for (int i = index; i < nums.size(); i++)   //向右边扩散
		{
			if (nums[rightindex] == target)
			{
				rightindex++;
				continue;
			}
			break;
		}
		re[0] = leftindex + 1;
		re[1] = rightindex - 1;	
	}
	return re;
    }
};

运行结果:

---

---

代码/第二种想法(二分):

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
    vector<int> re;
	int left = 0;
	int right = nums.size() - 1;
	int index;

	int leftidx = -1;
	int rightidx = -1;

	while (left <= right)        //算出左下标
	{
		index = (left + right) / 2;
		if (nums[index] == target)
		{
			leftidx = index;
			right = index - 1;
			continue;
		}
		if (nums[index] < target)
			left = index + 1;
		if (nums[index] > target)
			right = index - 1;
	}

	left = 0;
	right = nums.size() - 1;

	while (left <= right)         //算出右下标
	{
		index = (left + right) / 2;
		if (nums[index] == target)
		{
			rightidx = index;
			left = index + 1;
			continue;
		}
		if (nums[index] < target)
			left = index + 1;
		if (nums[index] > target)
			right = index - 1;
	}

	re.push_back(leftidx);         //如果没有就是-1,有就是下标值
	re.push_back(rightidx);

	return re;
    }
};

运行结果:

总结:

用暴力比较容易想到,我一上来就想着两边扩散开来做,但是后面发现可能测试案例的数比较大,暴力算会慢很多.看到别人说用二分法找两次就想到一次找一个下标.速度果然快了很多.所以查找最好还是使用二分.