旋转排序数组
Leetcode上有五道旋转排序数组的题目，都是使用二分法。使用二分法的关键点是想到这样一个事实：每次二分，左半边和右半边肯定有一边是能确定有序的。利用这个性质来缩小待查区间。
首先要确定，nums[mid] 究竟和 nums[left] 以及 nums[right] 中的哪一个比较，可以把目标值套在一个可确定的区间里。
1. 找最小值问题
如果是找最小值，那么应当使得每次收缩区间，最小值仍然在区间内。 nums[mid] nums[left] 和 nums[right] 的比较可能有以下三种结果：以下左边指[left, mid]， 右边指[mid, right]，都是闭区间。
(1) 左 < 中， 中 < 右，那么 [左，右] 有序，最小值在左半边。
(2) 左 < 中， 中 > 右，如 2 3 4 0 1，左边可以确定有序，最小值在右半边。
(3) 左 > 中， 中 < 右，如 4 0 1 2 3，右边可以确定有序，最小值在左半边。
那么可以看出来，左和中的比较结果不能确定最小值落在哪边，如 (1)和(2)，但是右和中的比较结果可以确定最小值在哪边。所以，找最小值应当将中和右进行比较。
1.1.153. 寻找旋转排序数组中的最小值
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [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
如上所述，中与右比较，缩小最小值所在的区间。最后区间长度为1时就是最小值。
class Solution {
public:
int findMin(vector& nums) {
int left = 0, right = nums.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
//最小值在右半边
if(nums[mid] > nums[right]) left = mid + 1;
//最小值在左半边
else right = mid;
}
return nums[right];
}
}; 1.2. 154. 寻找旋转排序数组中的最小值 II
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [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
说明：这道题是 寻找旋转排序数组中的最小值 的延伸题目。
允许重复会影响算法的时间复杂度吗？会如何影响，为什么？
依然是中与右比较，缩小最小值所在的区间。但是可能会出现 中 == 右的情况，例如 2 0 1 1 1。这时，直接排除右端点来缩小区间，因为即使右端点是最小值，mid 仍然留在区间里，可以在之后被找到。最后区间长度为1时，就是最小值。
class Solution {
public:
int findMin(vector& nums) {
int left = 0, right = nums.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
//最小值在右半边
if(nums[mid] > nums[right]) left = mid + 1;
//最小值在左半边
else if(nums[mid] < nums[right]) right = mid;
//nums[mid] == nums[right] 直接排除右端点
else right--;
}
return nums[right];
}
}; 2. 找目标数问题
旋转之后，左右两边有一边是可以确定有序的，那么如果目标数可能在这个有序区间，就可以把区间缩小到这一边，否则就把区间缩小到另外一边。
同样的问题是：中值应当与左、右的哪一个比较，可以达到缩小区间的目的？
依然是三种情况：
(1) 左 < 中， 中 < 右，那么 [左，右] 有序。
(2) 左 < 中， 中 > 右，如 2 3 4 0 1，左边可以确定有序。
(3) 左 > 中， 中 < 右，如 4 0 1 2 3，右边可以确定有序。
那么可以看出来，左<中，可以确定左边有序，左>中，可以确定右边有序。右<中，可以确定左边有序，右>中，可以确定右边有序。
似乎判断有序的问题用左右值都可以，但因为编程实现的不同会出问题：考虑只有两个数的情况 [3 1]，目标数1。
如果使用左值与中值比较缩小区间的策略，中值下取整即 mid = (left + right) / 2。第一次，mid = 0, left = 0, 不满足 左 < 中，那么判断右边[mid, right]有序，mid = 0, right = 1, 但此时判断目标数是否在区间里使用的是 [mid, right]，但目标数1并不满足在区间 [3,1] 的条件，所以会让right = mid - 1 = -1，出现找不到的结果。 这一问题的原因是mid用了下取整，如果改成上取整就不会出现这个问题，即mid = (left + right + 1) /2 。但这种特例很难考虑周全。
如果使用中值与右值比较缩小区间的策略，可以规避上取整的问题。
2.1 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
如上所述，采用中值与右值比较的策略，判断哪边有序。如果目标数可能在有序的那一边，缩小区间到有序的那一边，否则缩小区间到另一边。
class Solution {
public:
int search(vector& nums, int target) {
int left = 0, right = nums.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
if(nums[mid] == target) return mid;
//右边有序
if(nums[mid] < nums[right])
{
//target可能在右边
if(nums[mid] < target && nums[right] >= target) left = mid + 1;
else right = mid - 1;
}
//左边有序
else
{
//target可能在左边
if(nums[mid] > target && nums[left] <= target) right = mid - 1;
else left = mid + 1;
}
}
if(right >= 0 && nums[right] == target) return right;
return -1;
}
}; 2.2 81. 搜索旋转排序数组 II
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [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 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
依然采用中值与右值比较缩小区间的策略，同样的，当出现中值==右值时，直接排除右端点来缩小区间，因为中值仍然在区间内，不会影响结果。
class Solution {
public:
bool search(vector& nums, int target) {
int left = 0, right = nums.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
if(nums[mid] == target) return true;
//右边有序
if(nums[mid] < nums[right])
{
if(nums[mid] < target && nums[right] >= target) left = mid + 1;
else right = mid - 1;
}
//左边有序
else if(nums[mid] > nums[right])
{
if(nums[mid] > target && nums[left] <= target) right = mid - 1;
else left = mid + 1;
}
else right--;
}
if(right >= 0 && nums[right] == target) return true;
return false;
}
}; 2.3 面试题 10.03. 搜索旋转数组
搜索旋转数组。给定一个排序后的数组，包含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]之间
首先要注意的是，旋转多次和旋转一次并没有区别，最终只有一个旋转点。所以问题和2.2很类似，但是这里要找的是target的最小下标。同样采用中值与右值比较的方式来缩小区间。
(1) arr[mid] < arr[right]，说明右边有序，如果 target满足 target > arr[mid] && target <= arr[right]，说明可能在 (mid, right]区间内，但是因为是要找最小下标，如果此时 arr[left] == target，直接返回left, 否则再进一步缩小区间 left = mid + 1。如果不满足，那么target只能在左半部分， right = mid。
(2) arr[mid] > arr[right]，说明左边有序。如果 target满足 target < arr[mid] && target >= arr[left]，说明可能在[left, mid)区间内，缩小区间 right = mid。如果不满足，那么target只能在右半部分，left = mid +1。
(3) arr[mid] == arr[right]，因为要找最小下标，right--，不影响结果。
class Solution {
//旋转多次和旋转一次没有区别，最终只有一个旋转点
public:
int search(vector& arr, int target) {
int left = 0, right = arr.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
if(arr[mid] < arr[right])
{
if(target > arr[mid] && target <= arr[right])
{
if(arr[left] == target) return left;
left = mid + 1;
}
else right = mid;
}
else if(arr[mid] > arr[right])
{
if(target >= arr[left] && target < arr[mid]) right = mid - 1;
else left = mid + 1;
}
else right--;
}
if(right >= 0 && arr[right] == target) return right;
return -1;
}
};