假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [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
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public:
int search(vector<int>& nums, int target) {
int L=0,R=nums.size()-1;
while(L<=R){
int mid = L+(R-L)/2;
if(nums[mid]==target) return mid;
else if(nums[L]<=nums[mid]){
if(target<nums[mid]&&target>=nums[L]){
R=mid-1;
}
else L=mid+1;
}
else {
if(target>nums[mid]&&target<=nums[R]){
L=mid+1;
}
else R=mid-1;
}
}
return -1;
}
};
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例 1:
输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
示例 2:
输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
进阶:
这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public:
bool search(vector<int>& nums, int target) {
int L=0,R=nums.size()-1;
while(L<=R){
int mid = L+(R-L)/2;
if(nums[mid]==target) return true;
if(nums[mid]==nums[L]){L++;continue;}
if(nums[mid]==nums[R]){R--;continue;}
else if(nums[L]<=nums[mid]){
if(target<nums[mid]&&target>=nums[L]){
R=mid-1;
}
else L=mid+1;
}
else {
if(target>nums[mid]&&target<=nums[R]){
L=mid+1;
}
else R=mid-1;
}
}
return false;
}
};
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。
示例 1:
输入: [3,4,5,1,2]
输出: 1
示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public:
int findMin(vector<int>& nums) {
//二分法:如果中间值比最右方值小,则最小值在左半段
//如果最小值比最右方值大。则最小值在右半段
int L=0;
int R= nums.size()-1;
//通过减小选择区间解决，也就是最后剩下的那个元素一定是最小值
while(L<R){
int mid = (L+R)/2;
if(nums[mid]>nums[R])L = mid+1;
else R=mid;
}
return nums[L];
}
};
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
注意数组中可能存在重复的元素。
示例 1：
输入: [1,3,5]
输出: 1
示例 2：
输入: [2,2,2,0,1]
输出: 0
说明：
这道题是 寻找旋转排序数组中的最小值 的延伸题目。
允许重复会影响算法的时间复杂度吗？会如何影响，为什么？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public:
int findMin(vector<int>& nums) {
int L=0,R=nums.size()-1;
while(L<R){
int mid=(L+R)/2;
if(nums[R]<nums[mid]){L =mid+1;}
else if(nums[R]>nums[mid]){ R = mid;}
else R= R-1;
}
return nums[L];
}
};
搜索旋转数组。给定一个排序后的数组，包含n个整数，但这个数组已被旋转过很多次了，次数不详。请编写代码找出数组中的某个元素，假设数组元素原先是按升序排列的。若有多个相同元素，返回索引值最小的一个。
示例1:
输入: arr = [15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], target = 5
输出: 8（元素5在该数组中的索引）
示例2:
输入：arr = [15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], target = 11
输出：-1 （没有找到）
提示:
arr 长度范围在[1, 1000000]之间
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-rotate-array-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public:
int search(vector<int>& arr, int target) {
int l=0;
int r=arr.size()-1;
while(l<r){
int mid = l+(r-l)/2;
if(arr[mid]==arr[l]){
if (arr[l] != target) {
l++;
} else {
r = l;
}
}
else if(arr[mid]<arr[l]){
if(arr[l]<=target || target<=arr[mid])r=mid;//在右边区间
else l=mid+1;
}
else if(arr[l]<arr[mid]){
if(arr[l]<=target&&target<=arr[mid])r=mid;//左边是有序
else l=mid+1;
}
}
return (arr[l] == target) ? l : -1;
}
};