搜索旋转排序数组(java)

1. 前述

搜索旋转排序数组 leetcode33
https://leetcode-cn.com/problems/search-in-rotated-sorted-array/

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

2. 思路

首先，题目要求O(log n)，毫无疑问要用二分以及递归。
根据二分后的结果
一共有两种不同的数组
[3,4,5,6,7,1,2]
[6,7,1,2,3,4,5]
观察
第一个的二分结果为
[3,4,5]以及[7,1,2]
第二个为
[6,7,1]以及[3,4,5]

显然分为两种不同的子数组
一种为有顺序的，另一种为旋转数组
需要对target值判断在哪个区间

对于有顺序的进行二分搜索即可，
对于旋转数组则进行递归解决即可

3. 代码

个人认为，我的代码还不够精炼，以及可能有用不到的处理，仅供参考

class Solution {
    public int search(int[] nums, int target) {

        return dg(nums,0,nums.length-1,target);
    }

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

        if (nums[left] <= nums[mid-1] && target > nums[left] && target < nums[mid-1]) {
            return binarySearch(nums, left, mid-1, target);
        }
        else if (nums[left] >= nums[mid-1] && (target > nums[left] || target < nums[mid-1])){
            return dg(nums, left, mid-1, target);
        }
        else if (nums[mid+1] <= nums[right] && target > nums[mid+1] && target < nums[right]){
            return binarySearch(nums, mid+1, right, target);
        }
        else if (nums[mid+1] >= nums[right] && (target > nums[mid+1] || target < nums[right])){
            return dg(nums, mid+1, right, target);
        }
        return -1;
    }

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