文章目录
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