【刷题之路Ⅱ】牛客 NC105 二分查找-II

一、题目描述

原题连接： NC105 二分查找-II
题目描述：
请实现有重复数字的升序数组的二分查找
给定一个 元素有序的（升序）长度为n的整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的第一个出现的target，
如果目标值存在返回下标，否则返回 -1

数据范围：0 <= n <= 100000
进阶:时间复杂度O(logn)，空间复杂度O(n)

示例1
输入： [1,2,4,4,5],4
返回值： 2
说明：从左到右，查找到第1个为4的，下标为2，返回2

示例2
输入： [1,2,4,4,5],3
返回值：-1

示例3
输入：[1,1,1,1,1],1
返回值： 0

二、解题

1、方法1——直接遍历

1.1、思路分析

既然题目中已经说了有序，那一个最朴素的方法就是直接遍历数组
当第一次遇到target就可以直接返回。

1.2、代码实现

有了以上思路，那我们写起代码来也就水到渠成了：

int search1(int* nums, int numsLen, int target) {
	assert(nums);
	int i = 0;
	for (i = 0; i < numsLen; i++) {
		if (nums[i] == target) {
			return i;
		}
	}
	return -1;
}

时间复杂度：O(n),n为数组长度，最坏情况下，我们需要遍历一遍数组
空间复杂度：O(1)，我们只需要用到常数级的额外空间。

2、方法2——找到后再往前继续找

2.1、思路分析

题目已经说明是升序的数组，那么相同的元素就一定是紧挨在一起的
所以当我们找到target时，可以继续再往它的前面寻找，如果它的前一个元素不等于target，则说明此时找到的就是第一次出现的target，若等于，则要继续往前找，直到前面的元素不等于target：

2.2、代码实现

有了以上分析，那我们写起代码来也就水到渠成了：

int search2(int* nums, int numsLen, int target) {
	assert(nums);
	int left = 0;
	int right = numsLen - 1;
	int mid = 0;
	while (left <= right) {
		mid = left + (right - left) / 2;
		if (target < nums[mid]) {
			right = mid - 1;
		}
		else if (target > nums[mid]) {
			left = mid + 1;
		}
		else {
			while (nums[mid - 1] == target) {
				mid--;
			}
			return mid;
		}
	}
	return -1;
}

时间复杂度：O(log2N)，N为数组的长度。
空间复杂度：O(1),我们只需要用到常数级的额外空间。

3、方法3——往左边逼近

3.1、思路分析

既然题目中已经说了有序，既然是要找到第一个出现的target，
那我们如果从右往左找，找到第一个大于target的元素，那这个元素的后一个元素不就是第一次出现的target了？！

所以我们可以这样设计算法：
只有当nums[mid] < target时，执行left = mid + 1，
其余时候(不用管nums[mid]是否等于target),一律都执行right = mid
这种做法其实保证了，不管什么时候right指向的元素都大于或等于target。所以当left和right即将要重合时，一定是left、mid、right这三者排成一排：

因为在重合之前执行的一定是left = mid + 1，且一定有nums[mid] < target。
故当left与right重合时，就可以判断lef指向的元素是否等于target,如果等于，则说明此时left指向的元素就是第一次出现的target，若不等于，则说明数组中不存在target。

3.2、代码实现

有了以上思路，那我们写起代码来也就水到渠成了：

int search3(int* nums, int numsLen, int target) {
	assert(nums);
	if (0 == numsLen) {
		return -1;
	}
	int left = 0;
	int right = numsLen - 1;
	int mid = 0;
	while (left < right) {
		mid = left + (right - left) / 2;
		if (nums[mid] < target) {
			left = mid + 1;
		}
		else {
			right = mid;
		}
	}
	return nums[left] == target ? left : -1;
}

时间复杂度：O(log2N)，N为数组长度。
空间复杂度，O(1)，我们只需要用到常数级的额外空间。

4、方法4——递归(判断左边界)

4.1、思路分析

通过上一题的解法我们应该能够得到启发：
其实只需要判断左边界left是否等于target即可，因为左边界的改动的条件一定是上一轮nums[mid] < target,说明target在mid后面，而左边界改动进行的操作又是left = mid + 1，那如果下次的nums[left] == target,不就恰好说明找到了第一次出现的target了吗？！
而对于右边界的改动，最左边界并没有什么影响，所以，不用判断右边界。
这个过程其实可以通过递归来实现，每一次递归都判断nums[left]是否等于target
如果等于，直接返回left即可，如果出现了left > rihgt，则说明找不到target，返回-1即可。

4.2、代码实现

有了以上思路，那我们写起代码来也就水到渠成了：

// 先写一个递归版的二分查找
int binary_search(int* nums, int left, int right, int target) {
	assert(nums);
	if (left > right) {
		return -1;
	}
	if (nums[left] == target) {
		return left;
	}
	int mid = left + (right - left) / 2;
	if (target < nums[mid]) {
		return binary_search(nums, left, mid - 1, target);
	}
	else if (target > nums[mid]) {
		return binary_search(nums, mid + 1, right, target);
	}
	else {
		return binary_search(nums, left, mid, target); // 如果相等，就往左边逼近，思路和方法3一样
	}

}

// 我们在查找函数中调用一次二分查找即可
int search(int* nums, int numsLen, int target) {
	assert(nums);
	if (0 == numsLen) {
		return -1;
	}
	return binary_search(nums, 0, numsLen - 1, target);
}