算法----二分查找

目录

两个模板

第一个满足某条件(大于等于target)的元素

最后一个满足某条件(小于等于target)的元素

数组是完全有序的

在一个有范围的区间里搜索确定一个结果

待查找数组不完全有序


两个模板

时间复杂度 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个元素,这个元素 有可能就是我们要找的元素

数组是完全有序的

在一个有范围的区间里搜索确定一个结果

69. x 的平方根

实现 int sqrt(int 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;
    }

35. 搜索插入位置

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

你可以假设数组中无重复元素。

示例 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;
    }

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

给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

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

进阶:

  • 你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗

第一个大于等于目标值的元素如果和目标值相等,该位置就是开始位置,否则返回-1,结束位置对应最后一个小于等于目标值的元素位置。

待查找数组不完全有序

33. 搜索旋转排序数组

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

在传递给函数之前,nums 在预先未知的某个下标 k0 <= 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;
    }

81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转,与上一题不同该题数组中的元素允许重复。

( 例如,数组 [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;
    }
}

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

假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] 。

请找出其中最小的元素。数组元素唯一。

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

数组可能存在重复元素

相当于找第一个小于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];
}
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值