在旋转过的有序数组中寻找目标值

题目

给定一个整数数组nums，按升序排序，数组中的元素各不相同。
nums数组在传递给search函数之前，会在预先未知的某个下标 t（0 <= t <= nums.length-1）上进行旋转，让数组变为[nums[t], nums[t+1], …, nums[nums.length-1], nums[0], nums[1], …, nums[t-1]]。
比如，数组[0,2,4,6,8,10]在下标2处旋转之后变为[6,8,10,0,2,4]
现在给定一个旋转后的数组nums和一个整数target，请你查找这个数组是不是存在这个target，如果存在，那么返回它的下标，如果不存在，返回-1

示例1
输入：
[6,8,10,0,2,4],10
返回值：
2

示例2
输入：
[6,8,10,0,2,4],3
返回值：
-1

分析

从描述信息中可以知道两点：

1. 数组中的值是互不相同的，即原数组严格单调递增。
2. 旋转后的数组被划分成两个有序数组。
   我们把数组从中间划分成两个数组left和right，假设left是有序的，那么right是由两部分有序序列组成，如果target
   在left中那么可以采用二分查找，否则在right中查找，这是一个递归调用。

代码

public class Solution {
    public int search (int[] nums, int target) {
        // write code here
        return findPosition(nums,0,nums.length-1,target);
    }
    public int findPosition(int[] nums,int begin,int end, int target) {
        if(begin > end) {
            return -1;
        }
        int mid = (begin + end) / 2;
        if(nums[mid] == target) {//如果相等返回下标
            return mid;
        } else if(nums[begin] < nums[mid]) { //如果左边有序
            if(target >= nums[begin] && target <= nums[mid]) {//target在左边
               return binarySearch(nums,begin,mid,target);
            } else {
                return findPosition(nums,mid+1,end,target);
            }
        } else {//如果右边有序
             if(target >= nums[mid] && target <= nums[end]) {//如果target在右边
               return binarySearch(nums,mid,end,target);
            } else {
                return findPosition(nums,begin,mid-1,target);
            }
        }
    }
    //二分查找
    public int binarySearch(int[]nums,int begin,int end,int target) {
        while(begin <= end) {
            int mid = (begin + end) / 2;
            if(nums[mid] == target) {
                return mid;
            } else if(nums[mid] > target) {
                end = mid - 1;
            } else {
                begin = mid + 1;
            }
        }
        return -1;
    }
}