33. 搜索旋转排序数组
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如,数组
[0,1,2,4,5,6,7]
可能变为[4,5,6,7,0,1,2]
)。搜索一个给定的目标值,如果数组中存在这个目标值,则返回它的索引,否则返回
-1
。你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0 输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3 输出: -1
解法一:
//时间复杂度O(logn), 空间复杂度O(1)
class Solution {
public:
int search(vector<int>& nums, int target) {
if(nums.size() == 0) return -1;
if(nums.size() == 1) return target == nums[0] ? 0 : -1;//数组长为1,直接判断
if(target > nums[nums.size() - 1] && target < nums[0]) return -1;//小于左边界且大于右边界,肯定不存在
int low = 0, high = nums.size() - 1;//找最大值点的下标,保存在high中
while(low <= high) {
int mid = low + (high - low) / 2;
if(mid < high && nums[mid] > nums[mid + 1]) {
high = mid;
break;
}
if(nums[mid] >= nums[low]) low = mid + 1;
else if(nums[mid] <= nums[high]) high = mid - 1;
}
if(low == nums.size()) low = 0, high = nums.size() - 1;//对应没有旋转的情况
else {
if(target > nums[high] || target < nums[high + 1]) return -1;//大于最大值或小于最小值,肯定不存在
low = target >= nums[0] ? 0 : high + 1;
high = target >= nums[0] ? high : nums.size() - 1;
}
while(low <= high) {//确定范围后开始正式查找target
int mid = low + (high - low) / 2;
if(nums[mid] < target) low = mid + 1;
else if(nums[mid] > target) high = mid - 1;
else return mid;
}
return -1;
}
};
解法二:
//时间复杂度O(logn), 空间复杂度O(logn)
class Solution {
public:
int normal_search(vector<int>& nums, int low, int high, int target) {
while(low <= high) {
int mid = low + (high - low) / 2;
if(nums[mid] < target) low = mid + 1;
else if(nums[mid] > target) high = mid - 1;
else return mid;
}
return -1;
}
int search(vector<int>& nums, int low, int high, int target) {
if(low == high) return nums[low] == target ? low : -1;//终止条件
int mid = low + (high - low) / 2;
if(nums[low] <= nums[mid]) {
int temp = normal_search(nums, low, mid, target);
if(temp != -1) return temp;
return search(nums, mid + 1, high, target);
}
else {
int temp = normal_search(nums, mid + 1, high, target);
if(temp != -1) return temp;
return search(nums, low, mid, target);
}
}
int search(vector<int>& nums, int target) {
if(nums.empty()) return -1;
return search(nums, 0, nums.size() - 1, target);
}
};
class Solution {
public:
int binarySearch(const vector<int>& nums, int left, int right, const int target) {
while (left <= right) {
int mid = left + (right - left) / 2;
if (target < nums[mid]) right = mid - 1;
else if (target > nums[mid]) left = mid + 1;
else return mid;
}
return -1;
}
int search(const vector<int>& nums, int left, int right, int target) {
if (left > right) return -1;
int mid = left + (right - left) / 2;
if (nums[mid] == target) return mid;
if (nums[left] == target) return left;
if (nums[right] == target) return right;
if (nums[mid] > nums[left]) {
if (target < nums[mid] && target > nums[left]) {
return binarySearch(nums, left + 1, mid - 1, target);
} else {
return search(nums, mid + 1, right, target);
}
} else {
if (target > nums[mid] && target < nums[right]) {
return binarySearch(nums, mid + 1, right, target);
} else {
return search(nums, left, mid - 1, target);
}
}
}
int search(vector<int>& nums, int target) {
return search(nums, 0, nums.size() - 1, target);
}
};
解法一:
- 先使用二分查找法搜索旋转点(如果有旋转,旋转点就是最大值的点)的下标high;
- 如果上一步完成后low == nums.size(),说明数组没有旋转(或者说是在最后一个位置发生旋转),直接全范围内二分查找,结束。否则进入步骤3;
- 此时high就是旋转点,它将数组一分为二为左、右两侧,判断target在哪一侧,将搜索范围重新设置,进行正常的二分搜索,结束。
解法二:
解法一的思路很清晰,但是实现细节稍多。解法二的思路更加简洁。它的核心思想是,将原数组一分为二之后,必有一个子数组有序,另一个子数组部分有序。
实现的思路就是,search进行递归地搜索,先将数组一分为二,根据low和mid元素大小关系判断出哪一个是有序子数组,在有序子数组上进行常规二分搜索,在部分有序子数组上进行递归搜索。终止条件是low == high。
2019/09/25 12:50