算法----二分查找

最新推荐文章于 2022-12-09 17:04:12 发布

烧毁的诺顿

最新推荐文章于 2022-12-09 17:04:12 发布

阅读量271

点赞数

本文链接：https://blog.csdn.net/gclonghorn/article/details/114532565

版权

两个模板

第一个满足某条件(大于等于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 的平方根，其中 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 在预先未知的某个下标 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;
    }

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
评论
算法----二分查找

两个模板时间复杂度 O(logn）第一个满足某条件(大于等于target)的元素while(left<right){ int mid=left+(right-left)/2; if(条件成立） //mid处条件成立，第一个满足条件的元素位置<=mid，[mid+1,right]内元素虽然满足条件但不是第一个故排除 right=mid; else //mid处条件不成立意味着[left,mid]内的...
复制链接

扫一扫