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

 

// nums = [4,5,6,7,0,1,2], target = 0 [a1,a2,a3,..,am,b1,b2,..,bn] b1<b2<..<bn<a1<a2<..<an
//1. target < a1  2. target > a1 3. target > bn && target < a1
func search(nums []int, target int) int {
    if len(nums) ==0{
        return -1
    }
    left, right := 0, len(nums)-1
    a1, bn := nums[0], nums[len(nums)-1]

    // 1.没有旋转的情况
    if a1<bn{
        return simpleSearch(nums,0,target)
    }

    //2. b1<b2<..<bn<a1<a2<..<an
    if target>bn&&target<a1{
        return -1
    }


    for left <= right {

        if nums[left] == target {
            return left
        }

        if nums[right] == target {
            return right
        }

        mid := (left + right) / 2
        switch {
        case nums[mid] == target:
            return mid
        case nums[mid] <target:
            if nums[mid]>a1{
                left = mid +1
                a1 = left
        }else{
            if target<a1{
                return simpleSearch(nums[mid:right],mid,target)
            }else{
                right = mid -1
                bn =right
            }

            }
        case nums[mid]>target:
            if nums[mid]<a1{
                right = mid -1
                bn = right
            }else{
                if target>bn{
                    return simpleSearch(nums[left:mid],left,target)
                }else{
                    left = mid +1
                }

            }

        }

    }
    return -1
}

func simpleSearch(nums []int,offset, target int) int{
    left,right := 0, len(nums)-1

    for left < right {
        mid:=(left+right)/2

        if nums[left]==target{
            return offset+left
        }
        if nums[right]==target{
            return offset+right
        }

        switch {
        case nums[mid]==target :
            return offset+ mid
        case nums[mid] < target :
            left = mid + 1
        case nums[mid] > target:
            right = mid -1
        }
    }

    return -1
}