写在前面:二分法用在有序序列上
1.35. 搜索插入位置
给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n)
的算法。
示例 1:
输入: nums = [1,3,5,6], target = 5 输出: 2示例 2:
输入: nums = [1,3,5,6], target = 2 输出: 1示例 3:
输入: nums = [1,3,5,6], target = 7 输出: 4提示:
1 <= nums.length <= 10^4
-10^4 <= nums[i] <= 10^4
nums
为 无重复元素 的 升序 排列数组-10^4 <= target <= 10^4
思路:
查找元素,又必须是lgn的复杂度,肯定是二分了。
其实二分法有两种写法,最主要的就是要分清楚不变量,或者说主要就在于如何去判断边界。
下面借卡哥的讲法介绍给大家:
1)判断边界为左闭右闭,此时while(left<=right),当nums[middle]>key时,需要将right=middle-1;因为middle在本循环中是要计算进的,当前这个middle肯定不是key值。
2)如果说定义 target 是在一个在左闭右开的区间里,也就是[left, right) ,那么二分法的边界处理方式则截然不同。
有如下两点:
- while (left < right),这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle,因为当前nums[middle]不等于target,去左区间继续寻找,而寻找区间是左闭右开区间,所以right更新为middle,即:下一个查询区间不会去比较nums[middle]
【摘自:代码随想录 (programmercarl.com)】
代码:
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
left,right = 0,len(nums)-1
while left<=right:
middle=left+(right - left)//2
if nums[middle] > target:
right=middle-1
elif nums[middle] < target:
left=middle+1
else:
return middle
return right+1
思考:
通过AC发现了,当不存在该元素时,该元素所在位置为right+1。
2.74. 搜索二维矩阵
给你一个满足下述两条属性的 m x n
整数矩阵:
- 每行中的整数从左到右按非严格递增顺序排列。
- 每行的第一个整数大于前一行的最后一个整数。
给你一个整数 target
,如果 target
在矩阵中,返回 true
;否则,返回 false
。
示例 1:
输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3 输出:true示例 2:
输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13 输出:false提示:
m == matrix.length
n == matrix[i].length
1 <= m, n <= 100
-10^4 <= matrix[i][j], target <= 10^4
思路:
由于二维矩阵固定列的「从上到下」或者固定行的「从左到右」都是升序的。
因此我们可以使用两次二分来定位到目标位置:
第一次二分:从第 0 列中的「所有行」开始找,找到合适的行 row
第二次二分:从 row 中「所有列」开始找,找到合适的列 col
代码:java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length, n = matrix[0].length;
// 第一次二分:定位到所在行(从上往下,找到最后一个满足 matrix[x]][0] <= t 的行号)
int l=0,r=m-1;
while(l<r){
int mid=l+r+1 >> 1;
if(matrix[mid][0]<=target){
l=mid;
}else{
r=mid-1;
}
}
int row = r;
if(matrix[row][0]==target)return true;
if(matrix[row][0]>target)return false;
//第二次二分
l=0;r=n-1;
while(l<r){
int mid=l + r + 1 >> 1;
if(matrix[row][mid]<=target){
l=mid;
}else{
r=mid-1;
}
}
int col =r;
return matrix[row][col] == target;
}
}
3.34. 在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums
,和一个目标值 target
。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target
,返回 [-1, -1]
。
你必须设计并实现时间复杂度为 O(log n)
的算法解决此问题。
示例 1:
输入:nums = [5,7,7,8,8,10], target = 8 输出:[3,4]示例 2:
输入:nums = [5,7,7,8,8,10], target = 6 输出:[-1,-1]示例 3:
输入:nums = [], target = 0 输出:[-1,-1]
提示:
0 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9
nums
是一个非递减数组-10^9 <= target <= 10^9
思路:
1.第一种想法:
边界不要想太多,就两段二分查找就好,不要找到一个mid后再循环左右移动下标,这样时间复杂度在一些情况下会退化为O(N)
2.第二种想法:
考虑 target开始和结束位置,其实我们要找的就是数组中「第一个等于 target的位置」(记为 leftIdx)和「第一个大于 target的位置减一」(记为 rightIdx)。
代码:
第一种:python
class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
def search(self,nums:List[int],target:int,left:int,right:int,lower:bool):
res=-1
while left<=right:
mid=(left+right)//2
if nums[mid]<target:
left=mid+1
elif nums[mid]>target:
right=mid-1
elif nums[mid]==target and lower:
res = mid
right=mid-1
elif nums[mid]==target:
res=mid
left=mid+1
return res
n=len(nums)
left,right=0,n-1
res=[]
res.append(search(self,nums,target,left,right,True))
if res[0]==-1:
return [-1,-1]
res.append(search(self,nums,target,left,right,False))
return res
第二种:
class Solution {
public int[] searchRange(int[] nums, int target) {
int leftIdx = binarySearch(nums, target, true);
int rightIdx = binarySearch(nums, target, false) - 1;
if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {
return new int[]{leftIdx, rightIdx};
}
return new int[]{-1, -1};
}
public int binarySearch(int[] nums, int target, boolean lower) {
int left = 0, right = nums.length - 1, ans = nums.length;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > target || (lower && nums[mid] >= target)) {
right = mid - 1;
ans = mid;
} else {
left = mid + 1;
}
}
return ans;
}
}
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)
的算法解决此问题。
示例 1:
输入:nums = [4,5,6,7,0,1,2], target = 0 输出:4示例 2:
输入:nums = [4,5,6,7,0,1,2], target = 3 输出:-1示例 3:
输入:nums = [1], target = 0 输出:-1
提示:
1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums
中的每个值都 独一无二- 题目数据保证
nums
在预先未知的某个下标上进行了旋转 -10^4 <= target <= 10^4
思路:
首先寻找旋转点的序号,设为W,然后直接将其旋转复原(使用列表的切片方法),旋转后就是正常的非递减序列,然后进行二分查找,找到后按照以下图解,可知,需要对现有序号做一个映射!
具体映射转换关系,见代码!
代码:
class Solution:
def search(self, nums: List[int], target: int) -> int:
warn=0
n=len(nums)
i=1
while i <= n-1:#寻找旋转点的序号,[4,5,6,1,2,3]即warn=3
if nums[i]<nums[i-1]:
start=nums[i:]
warn=i
nums=start+nums[:i]
# print(nums)
break
i+=1
left,right=0,len(nums)-1
res=-1
while left <= right:#正常有序情况下的二分,查出来的顺序,应该要进行映射
mid = left+(right-left)//2
if nums[mid]>target:
right=mid-1
elif nums[mid]<target:
left=mid+1
else:
res=mid
# print(res)
break
if res==-1:
# print(".."+str(res))
return res
if res < n-warn:#如果位置(下标)在旋转的前半段上,也就是小于n-warn
return res+warn
else:#否则就在后半段,那么就应该将res-warn,也就是前移warn位(错了),应该是移动(n-warn)位
return res-n+warn
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)
的算法解决此问题。
示例 1:
输入:nums = [3,4,5,1,2] 输出:1 解释:原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。示例 2:
输入:nums = [4,5,6,7,0,1,2] 输出:0 解释:原数组为 [0,1,2,4,5,6,7] ,旋转 3 次得到输入数组。示例 3:
输入:nums = [11,13,15,17] 输出:11 解释:原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。提示:
n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums
中的所有整数 互不相同nums
原来是一个升序排序的数组,并进行了1
至n
次旋转
思路:
代码:
6.4. 寻找两个正序数组的中位数
给定两个大小分别为 m
和 n
的正序(从小到大)数组 nums1
和 nums2
。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n))
。
示例 1:
输入:nums1 = [1,3], nums2 = [2] 输出:2.00000 解释:合并数组 = [1,2,3] ,中位数 2示例 2:
输入:nums1 = [1,2], nums2 = [3,4] 输出:2.50000 解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5