题目
来源:LeetCode.
整数数组 nums 按升序排列,数组中的值 互不相同 。
在传递给函数之前,nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了 旋转,
使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标 从 0 开始 计数)。
例如, [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ,如果 nums 中存在这个目标值 target ,
则返回它的下标,否则返回 -1 。
示例 1:
输入:nums = [4,5,6,7,0,1,2], target = 0
输出:4
示例 2:
输入:nums = [4,5,6,7,0,1,2], target = 3
输出:-1
示例 3:
输入:nums = [1], target = 0
输出:-1
提示:
- 1 < = n u m s . l e n g t h < = 5000 1 <= nums.length <= 5000 1<=nums.length<=5000
- − 1 0 4 < = n u m s [ i ] < = 1 0 4 -10^4 <= nums[i] <= 10^4 −104<=nums[i]<=104
- n u m s nums nums 中的每个值都 独一无二
- 题目数据保证 nums 在预先未知的某个下标上进行了旋转
- − 1 0 4 < = t a r g e t < = 1 0 4 -10^4 <= target <= 10^4 −104<=target<=104
接下来看一下解题思路:
思路:二分法:
这个题在数组里面寻找指定的值,并返回下标,可以通过 循环遍历
来查找,但是时间复杂度是 O(n)
。
二分查找适用场景:有序或者部分有序,基本使用二分搜索及其变种;
因为每次搜索数据的一半,时间复杂度
O
(
l
o
g
n
)
O(logn)
O(logn)
将数组从中间分开成左右两部分的时候,一定有一部分的数组是有序的。
拿示例来看,我们从
6
6
6 这个位置分开以后数组变成了
[
4
,
5
,
6
]
[4, 5, 6]
[4,5,6] 和
[
7
,
0
,
1
,
2
]
[7, 0, 1, 2]
[7,0,1,2] 两个部分,其中左边
[
4
,
5
,
6
]
[4, 5, 6]
[4,5,6] 这个部分的数组是有序的,其他也是如此。
可以在常规二分查找的时候查看当前 m i d mid mid 为分割位置分割出来的两个部分 [ l e f t , m i d ] [left, mid] [left,mid] 和 [ m i d + 1 , r i g h t ] [mid + 1, right] [mid+1,right] 哪个部分是有序的,并根据有序的那个部分确定该如何改变二分查找的上下界,因为能够根据有序的那部分判断出 t a r g e t target target 在不在这个部分:
- 如果 [ l e f t , m i d − 1 ] [left, mid - 1] [left,mid−1] 是有序数组,且 t a r g e t target target 的大小满足 [ nums [ l e f t ] , nums [ m i d ] ) [\textit{nums}[left],\textit{nums}[mid]) [nums[left],nums[mid]),则应该将搜索范围缩小至 [ l e f t , m i d − 1 ] [left, mid - 1] [left,mid−1],否则在 [ m i d + 1 , r i g h t ] [mid + 1, right] [mid+1,right] 中寻找。
- 如果 [ m i d , r i g h t ] [mid, right] [mid,right] 是有序数组,且 t a r g e t target target 的大小满足 ( nums [ m i d + 1 ] , nums [ r i g h t ] ] (\textit{nums}[mid+1],\textit{nums}[right]] (nums[mid+1],nums[right]],则我们应该将搜索范围缩小至 [ m i d + 1 , r i g h t ] [mid + 1, right] [mid+1,right],否则在 [ l e f t , m i d − 1 ] [left, mid - 1] [left,mid−1] 中寻找。
如果 target = 5, 在 [left, mid - 1] 中寻找;
如果 target = 2, 在 [mid + 1, right] 中寻找;
如果 target = 6, 在 [left, mid - 1] 中寻找;
如果 target = 4, 在 [mid + 1, right] 中寻找;
public static int search(int[] nums, int target) {
int n = nums.length;
if (n < 1) {
return -1;
}
if (n == 1) {
return nums[0] == target ? 0 : -1;
}
int left = 0, right = n - 1;
while (left <= right) {
int mid = (left + right) >> 1;
if (target == nums[mid]) {
return mid;
}
// 说明左边是有序的
if (nums[0] <= nums[mid]) {
// 目标值在左侧序列
if (nums[0] <= target && target < nums[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
// 右边是有序的
} else {
if (nums[mid] < target && target <= nums[n - 1]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
}
return -1;
}
复杂度分析
时间复杂度:
O
(
log
n
)
O(\log n)
O(logn),其中
n
n
n 为
nums
\textit{nums}
nums 数组的大小。整个算法时间复杂度即为二分查找的时间复杂度
O
(
log
n
)
O(\log n)
O(logn)。
空间复杂度:
O
(
1
)
O(1)
O(1)。只需要常数级别的空间存放变量。