[Leetcode] [Tutorial] 二分查找

---

35. 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

Solution

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        low = 0
        high = len(nums) - 1
        while low <= high:
            i = (low + high) // 2
            if target < nums[i]:
                high = i - 1
            elif target > nums[i]:
                low = i + 1
            else:
                return i
        return low

在target大于nums[i]的情况下，你应该让low变为i+1，因为你已经知道nums[i]不等于target，所以下一次循环应该从i+1开始查找。同理，如果target小于nums[i]，你应该让high变为i-1，因为你已经知道nums[i]不等于target，所以下一次循环应该查找到i-1。

while循环的条件应该为low <= high，因为当low和high指向同一个元素时，我们仍然需要检查这个元素是否等于目标值。如果while循环的条件为low < high，那么当low和high指向同一个元素时，循环就会结束，可能会漏掉这个元素。

当我们在二分查找中没有找到目标值时：

• 如果目标值比所有数组元素都大，那么搜索将结束在low指针指向数组末尾之后的位置，high指针将在数组的最后一个元素。此时返回low是正确的，因为这是目标值应插入的位置。

• 如果目标值比所有数组元素都小，那么搜索将结束在low指针指向数组的第一个元素，high指针将在数组的起始位置之前。此时返回low也是正确的，因为这是目标值应插入的位置。

• 如果目标值在数组的中间位置并且没有找到，那么low指针将指向大于目标值的最小元素，high指针将指向小于目标值的最大元素。此时返回low同样是正确的，因为这是目标值应插入的位置。

33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

示例：
输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

Solution

当我们在旋转的有序数组中进行二分时，至少有一半的子数组（左半部分或右半部分）是有序的。

在每一步中，我们通过比较 nums[left] 和 nums[mid] 来确定哪一半是有序的。

一旦我们确定了有序的那一半：如果目标值在这个有序的范围内，我们可以像在经典的二分查找中那样更新边界；如果目标值不在这个范围内，那么它必定在另一半（无序部分）。所以我们更新边界到那一半，并继续查找。

对于无序的那一半，我们再次分成两部分，然后再次确定哪一部分是有序的，以此类推。

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

            # 如果左边是有序的
            if nums[left] <= nums[mid]:
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            # 否则右边是有序的
            else:
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        
        return -1

需要注意的是，当我们使用条件 nums[left] <= nums[mid]，我们考虑的是数组的左半部分是否为有序。包括等号 <= 是为了处理数组中只有两个元素的情况。

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

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]

若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例：
输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

Solution

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left, right = 0, len(nums) - 1
        min_val = float('inf')

        while left <= right:
            mid = (left + right) // 2
            min_val = min(min_val, nums[mid])
            
            if nums[left] <= nums[mid]:  # 左侧有序
                min_val = min(min_val, nums[left])
                left = mid + 1
            else:  # 左侧无序，最小值在左侧
                right = mid - 1
                
        return min_val

34. 在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

示例：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

Solution

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        def binary_search_left(nums, target):
            left, right = 0, len(nums) - 1
            while left <= right:
                mid = left + (right - left) // 2
                if nums[mid] < target:
                    left = mid + 1
                else:
                    right = mid - 1
            return left

        def binary_search_right(nums, target):
            left, right = 0, len(nums) - 1
            while left <= right:
                mid = left + (right - left) // 2
                if nums[mid] <= target:
                    left = mid + 1
                else:
                    right = mid - 1
            return right

        left, right = binary_search_left(nums, target), binary_search_right(nums, target)
        if left <= right:
            return [left, right]
        else:
            return [-1, -1]

我们想要找到目标值的最左边位置。这就意味着，当 nums[mid] 小于目标值时，左边界一定在 mid 的右侧。相反，当 nums[mid] 大于或等于目标值时，左边界一定在 mid 的左侧或正好是 mid。

当循环结束时（即 left > right），left 变量将指向搜索区间的右侧界限的下一个位置。考虑到我们已经排除了所有小于目标值的元素，所以此时 left 指向的位置将是第一个大于或等于目标值的位置。

74. 搜索二维矩阵

给你一个满足下述两条属性的 m x n 整数矩阵：

• 每行中的整数从左到右按非递减顺序排列。
• 每行的第一个整数大于前一行的最后一个整数。

给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。

Solution

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m, n = len(matrix), len(matrix[0])
        low_i, high_i, low_j, high_j = 0, m-1, 0, n-1

        while low_i <= high_i:
            i = (low_i + high_i) // 2
            if matrix[i][0] == target:
                return True
            elif matrix[i][0] < target:
                low_i = i + 1
            else:
                high_i = i - 1
        
        while low_j <= high_j:
            j = (low_j + high_j) // 2
            if matrix[high_i][j] == target:
                return True
            elif matrix[high_i][j] < target:
                low_j = j + 1
            else:
                high_j = j - 1

        return False

若将矩阵每一行拼接在上一行的末尾，则会得到一个升序数组，我们可以在该数组上二分找到目标元素。假设有 m 行 n 列的二维数组，那么一维索引 mid 对应的二维索引就是 (mid // n, mid % n)。使用 divmod() 函数可以更加方便地得到这两个值。

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        if not matrix:
            return False

        m, n = len(matrix), len(matrix[0])
        low, high = 0, m * n - 1

        while low <= high:
            mid = (low + high) // 2
            row, col = divmod(mid, n)
            
            if matrix[row][col] == target:
                return True
            elif matrix[row][col] < target:
                low = mid + 1
            else:
                high = mid - 1
        
        return False