33_搜索旋转排序数组

'''
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
'''
class Solution:
    '''
    算法1：模式1，先找到最小值，再对分查找target
    执行用时 :144ms, 在所有 python3 提交中击败了7.82%的用户
    内存消耗 :29.2 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search(self, nums:list, target: int) -> int:
        if not nums:
            return -1
        import bisect
        L, R, key = 0, len(nums)-2, nums[-1]
        while L <= R:
            m = (L + R) // 2
            if nums[m] > key:
                L = m + 1
            else:
                R = m - 1
        if L > 0 and target > nums[-1]: #左侧寻找
            p = bisect.bisect_left(nums, target, 0, L) 
        else:#右侧寻找
            p = bisect.bisect_left(nums, target, L, len(nums))
        if p < len(nums) and nums[p] == target:
            return p
        else:
            return -1
    
    '''
    算法2：另一种模式1，先找到最小值，再对分查找target
    执行用时 :112ms, 在所有 python3 提交中击败了7.82%的用户
    内存消耗 :29.5 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search2(self, nums:list, target: int) -> int:
        if not nums:
            return -1
        import bisect
        L, R = 0, len(nums)-1
        while L < R:
            m = (L + R) // 2
            if nums[m] < nums[R]:
                R = m
            else:
                L = m + 1
        if L > 0 and target > nums[-1]: #左侧寻找
            p = bisect.bisect_left(nums, target, 0, L) 
        else:#右侧寻找
            p = bisect.bisect_left(nums, target, L, len(nums))
        if p < len(nums) and nums[p] == target:
            return p
        else:
            return -1
        
    '''
    算法3：直接分区间查找。m将数组分成两部分，总有一侧是纯递增数组（也可能两边都是纯递增），
    若nums[m] >= nums[L],则[L:m]是一个递增区间，否则[m:R]是一个递增区间。
    我们可以先判断target是否处于纯递增区间，再来更新边界值
    执行用时 :132ms, 在所有 python3 提交中击败了7.49%的用户
    内存消耗 :29.5 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search3(self, nums:list, target: int) -> int:
        if not nums:
            return -1
        L, R = 0, len(nums)-1
        while L <= R:
            m = (L + R) // 2
            if nums[m] == target:
                return m
            elif nums[m] >= nums[L]:#[L:m]是一个递增区间
                if nums[L] <= target < nums[m]:#target介于单调递增的[L:m]区间
                    R = m - 1
                else:
                    L = m + 1
            else:  #[m:R]是一个递增区间
                if nums[m] < target <= nums[R]:#target介于单调递增的[m:R]区间
                    L = m + 1
                else:
                    R = m - 1
        return -1
    
    '''
    算法4：算法3的一个变式，不是查找target，而是查找第一个不小于target的元素
    执行用时 :116ms, 在所有 python3 提交中击败了7.49%的用户
    内存消耗 :29.5 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search4(self, nums:list, target: int) -> int:
        if not nums:
            return -1
        L, R = 0, len(nums) - 1
        while L < R:
            m = (L + R) // 2
            if nums[m] >= nums[L]:#[L:m]是一个递增区间
                if nums[L] <= target <= nums[m]:#target介于单调递增的[L:m]区间
                    R = m
                else:
                    L = m + 1
            else: #[m:R]是一个递增区间
                if nums[m] <= target <= nums[R]:#target介于单调递增的[m:R]区间
                    L = m
                else:
                    R = m - 1
        return L if nums[L] == target else -1

    
x = Solution()
a = [4,5,6,7,0,1,2]
for i in range(-2, 10):
    print(i, x.search(a, i), x.search2(a, i), x.search3(a, i), x.search4(a, i))