目录
两个模板
时间复杂度 O(logn)
第一个满足某条件(大于等于target)的元素
while(left<right)
{
int mid=left+(right-left)/2;
if(条件成立) //mid处条件成立,第一个满足条件的元素位置<=mid,[mid+1,right]内元素虽然满足条件但不是第一个故排除
right=mid;
else //mid处条件不成立 意味着[left,mid]内的元素都不满足条件排除
left=mid+1;
}
return left; //退出循环的时候 left 和 right 重合,区间 [left, right] 只剩下1个元素,这个元素 有可能就是我们要找的元素
最后一个满足某条件(小于等于target)的元素
while(left<right)
{
int mid=left+(right-left+1)/2;//注意+1,否则可能陷入死循环
if(条件成立) //条件成立,最后一个满足条件的元素位置>=mid,[left,mid-1]内部的元素都满足条件但不是最后一个,故排除
left=mid;
else //mid处条件不成立 意味着[mid,right]的都不满足条件,排除掉。
right=mid-1;
}
return left; //退出循环的时候 left 和 right 重合,区间 [left, right] 只剩下1个元素,这个元素 有可能就是我们要找的元素
数组是完全有序的
在一个有范围的区间里搜索确定一个结果
实现 int sqrt(int x)
函数。计算并返回 x 的平方根,其中 x 是非负整数。由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去。输入: 8 输出: 2 说明: 8 的平方根是 2.82842..., 由于返回类型是整数,小数部分将被舍去。
//本题求满足条件n*n<x的最后一个n
public int mySqrt(int x) {
long left=0,right=x; //本题注意x取值范围是long
while(left<right)
{
long mid=left+(right-left+1)/2;
if(mid*mid<=x)
left=mid;
else
right=mid-1;
}
return (int)left;
}
给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
public int searchInsert(int[] nums, int target) {
//找>=target的第一个位置
int left=0,right=nums.length; //坑在这儿,插入位置可能在数组末尾,所以right不是nums.length-1
while(left<right)
{
int mid = left+(right-left)/2;
if(nums[mid]>=target)
right=mid;
else
left=mid+1;
}
return left;
}
给定一个按照升序排列的整数数组 nums
,和一个目标值 target
。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target
,返回 [-1, -1]
。
进阶:
- 你可以设计并实现时间复杂度为
O(log n)
的算法解决此问题吗
第一个大于等于目标值的元素如果和目标值相等,该位置就是开始位置,否则返回-1,结束位置对应最后一个小于等于目标值的元素位置。
待查找数组不完全有序
整数数组 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
。
示例 1:
输入:nums = [4,5,6,7,0,1,2] target = 0
输出:4
思路:利用局部单调性,逐步缩小搜索区间。只有在单调区间里,才能通过target和nums[mid]的比较确定target的下标和mid的大小关系,进而缩小搜索区间。
- 通过nums[mid]和nums[left]或nums[right]的比较,可以判断左半部分还是右半部分时单调区间,
- int mid=left+(right-left)/2必须和right=mid;left=mid+1搭配, int mid=left+(right-left+1)/2必须和left=mid,right=mid-1搭配,否则会陷入死循环。
- 因为查找元素是否存在,所以不管是找元素第一次出现还是最后一次出现都可以3。这两种搭配都可行,但是判断条件要做相应的改变。比如若选用第一种target<=nums[mid]才能得到right=mid,若选用第二种target<nums[mid]才能得到right=mid-1.
public int search(int[] nums, int target) {
int left=0,right=nums.length-1;
while(left<right)
{
int mid=left+(right-left)/2;
if(nums[mid]>=nums[0]) //mid在左半部分,[left,mid]是单调区间
{
if(nums[0]<=target&&target<=nums[mid])//减而治之,根据单调性,满足此条件说明target一定不在[mid+1,right]内
right=mid;
else //排除法。不满足单调特性的target一定不在[left,mid]内;
left=mid+1;
}
else //mid在右半部分,[mid,right]是单调区间
{
if(nums[mid]<target&&target<=nums[right]) //
left=mid+1;
else
right=mid;
}
}
if(nums[left]==target)return left;
return -1;
}
public int search(int[] nums, int target) {
int left=0,right=nums.length-1;
while(left<right)
{
int mid=left+(right-left+1)/2;
if(nums[mid]>=nums[0]) //mid在左半部分,[left,mid]是单调区间
{
if(nums[0]<=target&&target<nums[mid])//根据单调性,满足此条件说明target一定不在[mid,right]内
right=mid-1;
else //target一定不在[left,mid-1]内;
left=mid;
}
else //mid在右半部分,[mid,right]是单调区间
{
if(nums[mid]<=target&&target<=nums[right])
left=mid;
else
right=mid-1;
}
}
if(nums[left]==target)return left;
return -1;
}
假设按照升序排序的数组在预先未知的某个点上进行了旋转,与上一题不同该题数组中的元素允许重复。
( 例如,数组 [0,0,1,2,2,5,6]
可能变为 [2,5,6,0,0,1,2]
)。
输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
与上题相比唯一的变化在于,对于10111 和 11101 这种。此种情况下 nums[left] == nums[mid],分不清到底是前面有序还是后面有序,此时 left++ 即可。相当于去掉一个重复的干扰项nums[left](反正还有nums[mid]呢)。
若是以nums[right]为参考,nums[right]==nums[mid]时,right--即可。
以nums[left]为参考判断前半部分有序还是后半部分有序
public boolean search(int[] nums, int target) {
int left=0,right=nums.length-1;
while(left<right)
{
int mid=left+(right-left)/2;
if (nums[left] == nums[mid]) { //无法判断前有序后有序
if(nums[left]==target)return true; //坑,不然若target就是nums[left]也被排除掉了。比如剩2个元素,0 1,left=mid=0,target=0,
left++; //排除重复项,退化为遍历查找
continue;
}
if(nums[left]<nums[mid]) //前半部分有序
{
if(nums[left]<=target&&target<=nums[mid])
{
right=mid;
}
else
left=mid+1;
}
else
{
if(nums[mid]<target&&target<=nums[right])//后半部分有序
{
left=mid+1;
}
else
right=mid;
}
}
if(nums[left]==target)return true;
return false;
}
以nums[right]为参考判断前半部分有序还是后半部分有序,区别仅在于判断条件和排除重复元素时
public boolean search(int[] nums, int target) {
int left=0,right=nums.length-1;
while(left<right)
{
int mid=left+(right-left)/2;
if (nums[right] == nums[mid]) {
if(nums[right]==target)return true; //坑
right--;
continue;
}
if(nums[right]<nums[mid])
{
if(nums[left]<=target&&target<=nums[mid])
{
right=mid;
}
else
left=mid+1;
}
else
{
if(nums[mid]<target&&target<=nums[right])
{
left=mid+1;
}
else
right=mid;
}
}
if(nums[left]==target)return true;
return false;
}
}
假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如,数组 [0,1,2,4,5,6,7]
可能变为 [4,5,6,7,0,1,2]
。
请找出其中最小的元素。数组元素唯一。
数组可能存在重复元素
相当于找第一个小于nums[left]或nums[right]的元素,这题坑在于对于[1,3,5] [5,3,1]这种情况,若用if (nums[mid]<nums[left]) right=mid; 找第一个满足条件的值时,若没有找到符合条件的元素,那么指针最后是在数组末尾。所以对于1.3.5 找第一个小于1的元素找不到,那么指针在末尾是5.对于5 3 1,找到第一个小于5的元素是3.所以只能以nums[right]为参考。
class Solution {
public int findMin(int[] nums) {
int left=0,right=nums.length-1;
while(left<right)
{
int mid=left+(right-left)/2;
if(nums[mid]==nums[right])
right--;
else if(nums[mid]<nums[right])
{
right=mid;
}
else
left=mid+1;
}
return nums[left];
}
}