leecode 解题总结：33. Search in Rotated Sorted Array

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
/*
问题:
Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

分析:
这是程序员面试金典的一道题目。是在旋转数组中查找一个元素。
设数组为A,长度为len,设查找元素为target，设旋转的枢轴为pivot，初始low=0,high=len-1
mid = low + (high-low)/2;
如果A[low] < target,那么元素只可能在旋转数组的左侧部分(因为A[low]~A[pivot]是升序的，A[pivot+1]~A[high]是升序的，且A[0]>A[len-1])
令high = mid
如果A[low] > target，元素在旋转数组的右侧部分
令low = mid
A[low] = target，找到元素，返回low
low > high，返回-1，表示找不到

输入:
7 6
4 5 6 7 0 1 2
7 2
4 5 6 7 0 1 2
7 3
4 5 6 7 0 1 2
6 3
2 3 2 2 2 2
6 3
2 2 2 2 3 2
6 3
2 2 2 2 2 4
输出:
2
6
-1
1
4
-1

关键:
1 需要用中间元素和两边元素比较来确定哪一边是升序，并根据升序两侧大小和给定值比较，确定最终在
A[low] < A[mid]说明左边是升序，例如4 5 6 7 0 1 2，如果有A[low] <= target <= A[high]，则在左半部分寻找
A[low] > A[mid]说明右边是升序，例如5 6 7 0 1 2 4

2左边=中间 != 右边，在右半部分查找
左边=中间 = 右边，先左半部分查找，如果左半部分查找不到，查找右半部分
*/

class Solution {
public:
int searchRotation(vector<int>& nums, int target ,int low ,int high) {
if(nums.empty() ||low < 0 || high >= nums.size() || low > high)
{
return -1;
}
int mid;
if(low < high)
{
mid = low + (high - low)/2;
//找到元素
if(nums.at(mid) == target)
{
return mid;
}
//左半部分升序
if(nums.at(low) < nums.at(mid))
{
//在左半部分升序中
if( nums.at(low) <= target && target <= nums.at(mid))
{
//high = mid;
return searchRotation(nums, target , low , mid);
}
//在右半部分中寻找
else
{
//low = mid + 1;
return searchRotation(nums , target , mid + 1 , high);
}
}
//右半部分升序
else if(nums.at(low) > nums.at(mid))
{
//在右半部分升序中
if(nums.at(mid) <= target && target <= nums.at(high))
{
//low = mid;
return searchRotation(nums , target , mid , high);
}
else
{
//high = mid - 1;
return searchRotation(nums , target , low , mid - 1);
}
}
//左边等于中间，可能low=high=mid时进入
else
{
//如果左边!=右边，查找右半部分
if(nums.at(low) != nums.at(high))
{
//low = mid + 1;
return searchRotation(nums , target , mid + 1, high);
}
//左边=中间=右边，先查左半部分，再查右半部分
else
{
int result = searchRotation(nums , target , low , mid);
if(-1 != result)
{
return result;
}
else
{
return searchRotation(nums , target , mid + 1 , high);
}
}
}
}
//low == high
else
{
if(nums.at(low) == target)
{
return low;
}
else
{
return -1;
}
}
}

int search(vector<int>& nums, int target) {
if(nums.empty())
{
return -1;
}
int len = nums.size();
int low = 0;
int high = len - 1;
int result = searchRotation(nums , target , low , high);
return result;
}
};

void process()
{
int value;
int num;
vector<int> datas;
int searchValue;
while(cin >> num >> searchValue)
{
datas.clear();
for(int i = 0 ; i < num ; i++)
{
cin >> value;
datas.push_back(value);
}
Solution solution;
int result = solution.search(datas , searchValue);
cout << result << endl;
}
}

int main(int argc , char* argv[])
{
process();
getchar();
return 0;
}