本文介绍 LeetCode 题集中，有关二分搜索的问题。

LeetCode 其他有关二分搜索的问题： LeetCode 题集：二分搜索（一）

33. Search in Rotated Sorted Array（搜索旋转排序数组）

问题描述

思路与代码

在本题中，由于输入数组经过了切分和重新拼接，因此可以先通过二分搜索找到切分点，进而判断目标值可能出现在前段还是后段，再进行二分搜索即可。具体情形如下：

• 若无切分，数组最小值为第一个元素
• 若有切分，数组最小值为切分后段的第一个元素

代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        """ get start and end point """

        # case 1: actually no rotating
        if nums[-1] > nums[0]:
            start, end = 0, len(nums) - 1

        # case 2: rotated
        else:
            # get the cut point
            start, end = 0, len(nums) - 1
            while start + 1 < end:
                mid = int((start + end) / 2)
                if nums[mid] > nums[start]:
                    start = mid
                else:
                    end = mid
            left_start, left_end, right_start, right_end = 0, end - 1, end, len(nums) - 1
            start = left_start if target >= nums[0] else right_start
            end = left_end if target >= nums[0] else right_end

        """ binary search """

        while start + 1 < end:
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return mid

            elif nums[mid] < target:
                start = mid
            else:
                end = mid

        if nums[start] == target:
            return start
        elif nums[end] == target:
            return end
        else:
            return -1

运行效果：

此外，还有一种无需确定切分点的方法，仅根据切分拼接后的数组特性即可实现二分搜索，代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return mid

            elif nums[mid] < nums[end]:  # 如未发生切分拼接，则只有该 elif 起作用，后面的 else 不起作用
                if nums[mid] <= target <= nums[end]:
                    start = mid
                else:
                    end = mid

            else:
                if nums[start] <= target <= nums[mid]:
                    end = mid
                else:
                    start = mid

        if nums[start] == target:
            return start
        elif nums[end] == target:
            return end
        else:
            return -1

运行效果：

81. Search in Rotated Sorted Array II（搜索旋转排序数组 II）

问题描述

思路与代码

本题为前一题的变体，但由于数组中可能存在重复值，很难在优于 O ( n ) O(n) O(n) 的前提下确定切分点，甚至很难在优于 O ( n ) O(n) O(n) 的前提下判断数组是否经过切分：

• 数组首项小于末项，一定没有经过切分；
• 数组首项大于末项，一定经过了切分；
• 数组的首项和末项相等，不确定，例： [ 1 , 1 , 1 ] , [ 1 , 2 , 1 ] , [ 3 , 1 , 3 ] [1, 1, 1], [1, 2, 1], [3, 1, 3] [1,1,1],[1,2,1],[3,1,3]

基于上述困难，本题参考前一题的第二种方法进行修改。

代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        start, end = 0, len(nums) - 1
        while start <= end:  # 由于循环中 start 和 end 至少有一个会移动，因此循环条件可以设为 <=
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return True

            elif nums[mid] < nums[end]:
                if nums[mid] <= target <= nums[end]:
                    start = mid + 1
                else:
                    end = mid - 1

            elif nums[mid] > nums[end]:
                if nums[start] <= target <= nums[mid]:
                    end = mid - 1
                else:
                    start = mid + 1

            else:  # 单独处理 nums[mid] = nums[end] 的情况，以应对重复值
                end -= 1

        return False

上述代码在循环体中对 mid 和 end 进行比较，对应地，也可以对 mid 和 start 进行比较， 代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        start, end = 0, len(nums) - 1
        while start <= end:  # 由于循环中 start 和 end 至少有一个会移动，因此循环条件可以设为 <=
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return True

            elif nums[start] < nums[mid]:
                if nums[start] <= target < nums[mid]:
                    end = mid - 1
                else:
                    start = mid + 1

            elif nums[start] > nums[mid]:
                if nums[mid] < target <= nums[end]:
                    start = mid + 1
                else:
                    end = mid - 1

            else:  # 单独处理 nums[mid] = nums[end] 的情况，以应对重复值
                start += 1

        return False

运行效果：

153. Find Minimum in Rotated Sorted Array（寻找旋转排序数组中的最小值）

问题描述

思路与代码

本题思路可参考本文第一题（LeetCode 33），即通过二分搜索找到数组的切分点。

代码如下：

class Solution:
    def findMin(self, nums: List[int]) -> int:
        # actually no rotating
        if nums[-1] > nums[0]:
            return nums[0]
            
        # get the cut point
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = int((start + end) / 2)
            if nums[mid] > nums[start]:
                start = mid
            else:
                end = mid
        return nums[end]

运行效果：

154. Find Minimum in Rotated Sorted Array II（寻找旋转排序数组中的最小值 II）

问题描述

思路与代码

本题为前一题的变体，区别在于本题允许数组中存在重复数字。当存在重复数字时，在二分搜索的循环体中，须对 mid 与端点相等的情况进行单独处理；此外，由于所求为最小值，故将 mid 与 end 相比较，若相等，将 end 自减 1，使循环继续而不影响结果。

代码如下：

class Solution:
    def findMin(self, nums: List[int]) -> int:
        # actually no rotating
        if nums[-1] > nums[0]:
            return nums[0]

        # get the minimum
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = int((start + end) / 2)

            if nums[mid] < nums[end]:
                end = mid
            elif nums[mid] > nums[end]:
                start = mid + 1
            else:  # 单独处理 nums[mid] = nums[end] 的情况，以应对重复值
                end -= 1

        return min(nums[start], nums[end])

此处需要注意的是，输出的最小值所在的位置并不一定是切分点。

运行效果：