将原本按顺序的数组旋转后进行查找，其实只需要进行正常的二分查找，对计算出的mid值进行一定的处理，就能够得到相应的结果，贴代码

class Solution {
public:
    int trans(int x,int k,int n)
    {
        return (x+k) % n;
    }
    int search(vector<int>& nums, int target) 
    {
        int n = nums.size();
        int k = 0;
        for(int i = 0 ; i < n-1 ; i++)
        {
            if(nums[i]>nums[i+1])
            {
                k = i+1;
                break;                
            }
        }
        int left = 0;
        int right = n;
        while(left<right)
        {
            int mid = (left+right)/2;
            if(nums[trans(mid,k,n)] == target)
            {
                return trans(mid,k,n);
            }
            else if(nums[trans(mid,k,n)]<target)
            {
                left = mid + 1;
            }
            else
            {
                right = mid;
            }
        }
        return -1;
    }
};

还有些很好的想法，第一个，通过找到分界点，得到两个分别有序的数组，进行二分查找。另外一个，直接进行二分，其中一个一定是有序的，另外一个可能有序可能无序，对有序的数组进行二分查找，然后对另外一个继续二分，其中一个是有序的，一个是有可能有序有可能无序的。二分查找的边界条件确实很难处理。贴代码

 1 class Solution {
 2 public:
 3     int search(vector<int>& nums, int target) 
 4     {
 5         int n = nums.size();
 6         int l = 0;
 7         int r = n-1;
 8         int mid;
 9         while(l<=r)
10         {
11             mid = (l+r)/2;
12             if(target == nums[mid])
13             return mid;
14             if(nums[l]<= nums[mid])
15             {
16                 if(target<nums[mid] && target>=nums[l])
17                 {
18                     r = mid;
19                 }
20                 else
21                 {
22                     l = mid+1;
23                 }
24             }
25             else
26             {
27                 if(target<=nums[r] && target>nums[mid])
28                 {
29                     l = mid+1;
30                 }
31                 else
32                 {
33                     r = mid;
34                 }
35             }
36         }
37         return -1;
38     }
39 };