LeetCode 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

题解：

/**
 * @Author dfpeng
 * @Date 2019/7/24
 */
public class Solution {

    int[] nums;
    int target;
    /**
     * 解题思路：
     * 首先找到旋转点的下标，即数组中最小元素的下标
     * 找到这个下标之后就可以将一个数组分为两个递增的数组
     * 再使用二分查找在递增数组里面查找
     * @param nums
     * @param target
     * @return
     */
    public int search(int[] nums, int target) {
        if (nums==null||nums.length==0){
            return -1;
        }
        if (nums.length==1){
            return nums[0]==target?0:-1;
        }
        this.nums=nums;
        this.target=target;
        int index=findIndex(0,nums.length-1);
        if (nums[index]==target){
            return index;
        }
        if (index==0){
            return binarySearch(0,nums.length-1);
        }
        if (nums[0]>target){
            return binarySearch(index,nums.length-1);
        }else{
            return binarySearch(0,index);
        }
    }

    /**
     * 找到旋转点的下标
     * @param left
     * @param right
     * @return
     */
    private int findIndex(int left,int right){
        if (nums[left]<nums[right]){
            //这种情况没有发生旋转
            return 0;
        }
        while (left<=right) {
            int pivot = (left + right) / 2;
            if (nums[pivot]>nums[pivot+1]){
                return pivot+1;
            }else{
                if (nums[pivot]<nums[left]){
                    //5 6 7 1 2 3 4
                    //nums[pivot]=1<nums[left]=5
                    right=pivot-1;
                }else{
                    //4 5 6 7 8 1 2 3
                    //nums[pivot]=7>nums[left]=4
                    left=pivot+1;
                }
            }
        }
        return 0;
    }

    private int binarySearch(int left,int right){
        while (left<=right){
            int mid=(left+right)/2;
            if (nums[mid]==target){
                return mid;
            }else{
                if(nums[mid]>target){
                    right=mid-1;
                }else{
                    left=mid+1;
                }
            }
        }
        return -1;
    }
}