数据结构与算法19-二分查找二、剑指Offer19-旋转数组的最小数字

变体一：查找第一个值等于给定值的元素

变体二：查找最后一个值等于给定值的元素

变体三：查找第一个大于等于给定值的元素

变体四：查找最后一个小于等于给定值的元素

解答开篇

小结

思考

对应LeetCode 33-搜索旋转排序数组

LeetCode 33-搜索旋转排序数组

这种旋转排序数组有几个内部规律：

1. 选中 中点后，要不然左升序，要不然右升序。
2. 左升序时，如果target在左边，则刚刚好相当于正常数组二分查找了；如果target在右边，则相当于要重新对右边数据从规律1开始考虑。
3. 右升序时，如果target在右边，则美滋滋；否则在左边的话，也要从规律1开始考虑。

上代码：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        low = 0
        high = len(nums)-1
        while (low <= high):
            mid = low + ((high - low)>>1)
            if nums[mid] == target:
                return mid

            if nums[low] <= nums[mid]:  # 左升序
                if nums[low] <= target < nums[mid]:  # 在左升序中
                    high = mid - 1
                else:  # 在右边，则对右边重新循环判断
                    low = mid + 1
            else:  # 右升序
                if nums[mid] < target <= nums[high]:
                    low = mid + 1
                else:  # 在左边，则对左边重新循环判断
                    high = mid - 1
        return -1

LeetCode 81-搜索旋转排序数组 II

上一题没有重复元素，这一题存在重复元素，所以我们在上一题的基础上，对重复元素进行判断，如果出现nums[low] == nums[mid]的情况，我们就将此时的low += 1，重新下次循环。

见代码：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: bool
        """
        low = 0
        high = len(nums)-1
        while (low <= high):
            mid = low + ((high - low)>>1)
            if nums[mid] == target:
                return True
            if nums[low] == nums[mid]:
                low += 1
            elif nums[low] <= nums[mid]:  # 左升序
                if nums[low] <= target < nums[mid]:  # 在左升序中
                    high = mid - 1
                else:  # 在右边，则对右边重新循环判断
                    low = mid + 1
            else:  # 右升序
                if nums[mid] < target <= nums[high]:
                    low = mid + 1
                else:  # 在左边，则对左边重新循环判断
                    high = mid - 1
        return False

LeetCode 153-寻找旋转排序数组中的最小值

所以上代码

class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        low = 0
        high = len(nums) - 1
        while (low <= high):
            mid = low + ((high-low)>>1)
            if low == high:
                return nums[low]
            if nums[mid] < nums[high]:  # 最小值在左边
            # 因为没有重复元素，所以不需要考虑相等的情况，但是下面154题得考虑相等的情况。
                high = mid  # 这里high不能为mid-1
            else:  # 最小值在右边
                low = mid + 1

        return -1

LeetCode 154-寻找旋转排序数组中的最小值 II & 剑指Offer19-旋转数组的最小数字

这题在上题的基础上加入了存在重复数字的情况。所以在上题代码的基础之上，我们加入个重复情况的判断，但是这里加重复情况判断，不能和81题一样，直接nums[low] == nums[mid]，则low +=1（因为旋转数组求最小值判断左边是行不通的，具体原因可以看上一题的分析）。上一题我们不需要考虑中间和右边相等的情况，这里需要考虑，那么如果中间和右边相等，那就high -= 1跳过此次循环即可。

class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        low = 0
        high = len(nums) - 1
        while (low <= high):
            if low == high:
                return nums[low]
            mid = low + ((high - low)>>1)
            if nums[mid] == nums[high]:
                high -= 1
            elif nums[mid] > nums[high]:
                low = mid + 1
            else:
                high = mid

        return -1

解法与LeetCode一致，直接上代码。

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here 
        low = 0
        high = len(rotateArray) - 1
        while (low <= high):
            if low == high:
                return rotateArray[low]
            mid = low + ((high-low)>>1)
            if rotateArray[mid] == rotateArray[high]:
                high -= 1
            elif rotateArray[mid] > rotateArray[high]:
                low = mid + 1
            else:
                high = mid            
        return -1