知识储备--基础算法篇-二分搜索
1.前言
最近准备开始刷算法题了，搜了很多相关的帖子，下面三个很不错，
计算机视觉秋招准备过程看这个：计算机视觉算法工程师-秋招面经 - 知乎 (zhihu.com)
https://zhuanlan.zhihu.com/p/399813916
复习深度学习相关知识看深度学习500问：
深度学习500问(github.com)https://github.com/scutan90/DeepLearning-500-questions刷题看这个：
算法模板，最科学的刷题方式，最快速的刷题路径，你值得拥有~ (github.com)https://github.com/greyireland/algorithm-pattern准备每天学习一点，刷几道题，后面将会持续更新。
2.基础算法篇-二分搜索
2.1二分搜索模板
给一个有序数组和目标值，找第一次/最后一次/任何一次出现的索引，如果没有出现返回-1
模板四点要素
-
1、初始化：start=0、end=len-1
-
2、循环退出条件：start + 1 < end
-
3、比较中点和目标值：A[mid] ==、 <、> target
-
4、判断最后两个元素是否符合：A[start]、A[end] ? target
时间复杂度 O(logn)，使用场景一般是有序数组的查找
模板： 模板分析： 二分查找 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台
如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用模板#1，代码更简洁
其他情况用模板#3
2.2常见题目
（1）给定一个包含 n 个整数的排序数组，找出给定目标值 target 的起始和结束位置。 如果目标值不在数组中，则返回[-1, -1]
思路：核心点就是找第一个 target 的索引，和最后一个 target 的索引，所以用两次二分搜索分别找第一次和最后一次的位置
func searchRange (A []int, target int) []int {
if len(A) == 0 {
return []int{-1, -1}
}
result := make([]int, 2)
start := 0
end := len(A) - 1
for start+1 < end {
mid := start + (end-start)/2
if A[mid] > target {
end = mid
} else if A[mid] < target {
start = mid
} else {
// 如果相等，应该继续向左找，就能找到第一个目标值的位置
end = mid
}
}
// 搜索左边的索引
if A[start] == target {
result[0] = start
} else if A[end] == target {
result[0] = end
} else {
result[0] = -1
result[1] = -1
return result
}
start = 0
end = len(A) - 1
for start+1 < end {
mid := start + (end-start)/2
if A[mid] > target {
end = mid
} else if A[mid] < target {
start = mid
} else {
// 如果相等，应该继续向右找，就能找到最后一个目标值的位置
start = mid
}
}
// 搜索右边的索引
if A[end] == target {
result[1] = end
} else if A[start] == target {
result[1] = start
} else {
result[0] = -1
result[1] = -1
return result
}
return result
}（2）给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
func searchInsert(nums []int, target int) int {
// 思路：找到第一个 >= target 的元素位置
start := 0
end := len(nums) - 1
for start+1 < end {
mid := start + (end-start)/2
if nums[mid] == target {
// 标记开始位置
start = mid
} else if nums[mid] > target {
end = mid
} else {
start = mid
}
}
if nums[start] >= target {
return start
} else if nums[end] >= target {
return end
} else if nums[end] < target { // 目标值比所有值都大
return end + 1
}
return 0
}（3）编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
-
每行中的整数从左到右按升序排列。
-
每行的第一个整数大于前一行的最后一个整数。
func searchMatrix(matrix [][]int, target int) bool {
// 思路：将2纬数组转为1维数组 进行二分搜索
if len(matrix) == 0 || len(matrix[0]) == 0 {
return false
}
row := len(matrix)
col := len(matrix[0])
start := 0
end := row*col - 1
for start+1 < end {
mid := start + (end-start)/2
// 获取2纬数组对应值
val := matrix[mid/col][mid%col]
if val > target {
end = mid
} else if val < target {
start = mid
} else {
return true
}
}
if matrix[start/col][start%col] == target || matrix[end/col][end%col] == target{
return true
}
return false
}（4）假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。 你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
func firstBadVersion(n int) int {
// 思路：二分搜索
start := 0
end := n
for start+1 < end {
mid := start + (end - start)/2
if isBadVersion(mid) {
end = mid
} else if isBadVersion(mid) == false {
start = mid
}
}
if isBadVersion(start) {
return start
}
return end
}（5）假设按照升序排序的数组在预先未知的某个点上进行了旋转( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 请找出其中最小的元素。
func findMin(nums []int) int {
// 思路：/ / 最后一个值作为target，然后往左移动，最后比较start、end的值
if len(nums) == 0 {
return -1
}
start := 0
end := len(nums) - 1
for start+1 < end {
mid := start + (end-start)/2
// 最后一个元素值为target
if nums[mid] <= nums[end] {
end = mid
} else {
start = mid
}
}
if nums[start] > nums[end] {
return nums[end]
}
return nums[start]
}（6）假设按照升序排序的数组在预先未知的某个点上进行了旋转 ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 请找出其中最小的元素。(包含重复元素)
func findMin(nums []int) int {
// 思路：跳过重复元素，mid值和end值比较，分为两种情况进行处理
if len(nums) == 0 {
return -1
}
start := 0
end := len(nums) - 1
for start+1 < end {
// 去除重复元素
for start < end && nums[end] == nums[end-1] {
end--
}
for start < end && nums[start] == nums[start+1] {
start++
}
mid := start + (end-start)/2
// 中间元素和最后一个元素比较（判断中间点落在左边上升区，还是右边上升区）
if nums[mid] <= nums[end] {
end = mid
} else {
start = mid
}
}
if nums[start] > nums[end] {
return nums[end]
}
return nums[start]
}（7）假设按照升序排序的数组在预先未知的某个点上进行了旋转。 ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。 你可以假设数组中不存在重复的元素。
func search(nums []int, target int) int {
// 思路：/ / 两条上升直线，四种情况判断
if len(nums) == 0 {
return -1
}
start := 0
end := len(nums) - 1
for start+1 < end {
mid := start + (end-start)/2
// 相等直接返回
if nums[mid] == target {
return mid
}
// 判断在那个区间，可能分为四种情况
if nums[start] < nums[mid] {
if nums[start] <= target && target <= nums[mid] {
end = mid
} else {
start = mid
}
} else if nums[end] > nums[mid] {
if nums[end] >= target && nums[mid] <= target {
start = mid
} else {
end = mid
}
}
}
if nums[start] == target {
return start
} else if nums[end] == target {
return end
}
return -1
}（8）假设按照升序排序的数组在预先未知的某个点上进行了旋转。 ( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。 编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。(包含重复元素)
func search(nums []int, target int) bool {
// 思路：/ / 两条上升直线，四种情况判断，并且处理重复数字
if len(nums) == 0 {
return false
}
start := 0
end := len(nums) - 1
for start+1 < end {
// 处理重复数字
for start < end && nums[start] == nums[start+1] {
start++
}
for start < end && nums[end] == nums[end-1] {
end--
}
mid := start + (end-start)/2
// 相等直接返回
if nums[mid] == target {
return true
}
// 判断在那个区间，可能分为四种情况
if nums[start] < nums[mid] {
if nums[start] <= target && target <= nums[mid] {
end = mid
} else {
start = mid
}
} else if nums[end] > nums[mid] {
if nums[end] >= target && nums[mid] <= target {
start = mid
} else {
end = mid
}
}
}
if nums[start] == target || nums[end] == target {
return true
}
return false
}3.leedcode实战
3.1 第35题
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。
class Solution(object):
def searchInsert(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
result = 0
mid = 0
start = 0
end = len(nums) - 1
while start + 1 < end:
mid = start + (end - start)/2
if nums[mid] == target:
result = mid
return result
elif nums[mid] < target:
start = mid
elif nums[mid] > target:
end = mid
if nums[start] == target:
result = start
elif nums[end] == target:
result = end
elif nums[start] > target:
result = start
elif nums[start] < target and nums[end] > target:
result = end
elif nums[end] < target:
result = end + 1
return result
3.2第74题
给你一个满足下述两条属性的 m x n 整数矩阵：
- 每行中的整数从左到右按非递减顺序排列。
- 每行的第一个整数大于前一行的最后一个整数。
给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。
class Solution(object):
def searchMatrix(self, matrix, target):
"""
:type matrix: List[List[int]]
:type target: int
:rtype: bool
"""
row = len(matrix)
col = len(matrix[0])
start = 0
end = row * col - 1
result = False
while start + 1 < end:
mid = start + (end - start)/2
if matrix[mid / col][mid % col] == target:
result = True
return result
elif matrix[mid / col][mid % col] > target:
end = mid
elif matrix[mid / col][mid % col] < target:
start = mid
if matrix[start / col][start % col] == target or matrix[end / col][end % col] == target:
result = True
else:
result = False
return result
3.3第34题
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
心得：第一次没写出来，想的是先去除掉重复的部分。正确的做法应该是在nums[mid]==target部分下文章，start=mid就是向后找结束位置，end=mid就是向前找起始位置。
class Solution(object):
def searchRange(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
if len(nums) == 0:
return [-1, -1]
elif len(nums) == 1 :
if nums[0] == target:
return [0, 0]
else:
return [-1, -1]
start = 0
end = len(nums) - 1
result = [-1, -1]
while start + 1 < end:
mid = start + (end - start)/2
if nums[mid] > target:
end = mid
elif nums[mid] < target:
start = mid
else:
end = mid
if nums[start] == target:
result[0] = start
elif nums[end] == target:
result[0] = end
else:
result[0] = -1
result[1] = -1
return result
start = 0
end = len(nums) - 1
while start + 1 < end:
mid = start + (end - start)/2
if nums[mid] > target:
end = mid
elif nums[mid] < target:
start = mid
else:
start = mid
if nums[end] == target:
result[1] = end
elif nums[start] == target:
result[1] = start
else:
result[0] = -1
result[1] = -1
return result
return result
3.4第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 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
心得：花了半小时没做出来，一开始想着先用nums[mid]与target来做判断，发现行不通，然后尝试两条上升的直线划区域做，想法没错但是陷入了误区。正确方法是两条上升的直线，然后利用start一定会移动到mid和end一定会移动到mid的条件来判断。
定理一：只有在顺序区间内才可以通过区间两端的数值判断target是否在其中。
定理二：判断顺序区间还是乱序区间，只需要对比 left 和 right 是否是顺序对即可，left <= right，顺序区间，否则乱序区间。
定理三：每次二分都会至少存在一个顺序区间。（感谢@Gifted VVilburgiX补充）
通过不断的用Mid二分，根据定理二，将整个数组划分成顺序区间和乱序区间，然后利用定理一判断target是否在顺序区间，如果在顺序区间，下次循环就直接取顺序区间，如果不在，那么下次循环就取乱序区间。
class Solution(object):
def search(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
if len(nums) == 0:
return -1
start = 0
end = len(nums) - 1
result = 0
while start + 1 < end:
mid = start + (end - start)/2
if nums[mid] == target:
return mid
if nums[start] < nums[mid]:
# 说明左半边是有序的
if target <= nums[mid] and target >= nums[start]:
end = mid
else:
start = mid
elif nums[end] > nums[mid]:
# 说明右半边是有序的
if target >= nums[mid] and target <= nums[end]:
# 用来确定目标是否在这一区域，决定保留哪边。
start = mid
else:
end = mid
if nums[start]==target:
result = start
elif nums[end]==target:
result = end
else:
result = -1
return result3.5第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 ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
心得：第一次提交失败，没有考虑到顺序数组的情况，所以加了一个if语句判断是否是顺序的。
class Solution(object):
def findMin(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if len(nums) == 1:
return nums[0]
start = 0
end = len(nums) - 1
while start + 1 < end:
mid = start + (end - start)/2
if nums[start] > nums[end]:
if nums[start] < nums[mid]:
start = mid
elif nums[mid] < nums[end]:
end = mid
else:
return nums[0]
if nums[start] > nums[end]:
return nums[end]
else:
return nums[start]
3.6第四题
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
心得：做了两个小时没做出来，有几个需要注意的地方，第一个是长度为偶数时中位数的计算需要除以2.0而不是2，如果除以二会自动去点小数部分。第二点就是要关注的不是索引指到的地方，而是需要注意已经判断出是更小的数的顺序。记录下最新判断出的更小的数。
class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
def getKthElement(k):
"""
- 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
- 这里的 "/" 表示整除
- nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
- nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
- 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
- 这样 pivot 本身最大也只能是第 k-1 小的元素
- 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
- 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
- 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
"""
index1, index2 = 0, 0
while True:
# 特殊情况
if index1 == m:
return nums2[index2 + k - 1]
if index2 == n:
return nums1[index1 + k - 1]
if k == 1:
return min(nums1[index1], nums2[index2])
# 正常情况
newIndex1 = min(index1 + k // 2 - 1, m - 1)
newIndex2 = min(index2 + k // 2 - 1, n - 1)
pivot1, pivot2 = nums1[newIndex1], nums2[newIndex2]
if pivot1 <= pivot2:
k -= newIndex1 - index1 + 1
index1 = newIndex1 + 1
else:
k -= newIndex2 - index2 + 1
index2 = newIndex2 + 1
m, n = len(nums1), len(nums2)
totalLength = m + n
if totalLength % 2 == 1:
return getKthElement((totalLength + 1) // 2)
else:
return (getKthElement(totalLength // 2) + getKthElement(totalLength // 2 + 1)) / 2