devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

算法——二分查找(一篇搞定)_二分查找csdn

作者：从前慢现在也慢 | 2024-05-06 06:15:36

赞

踩

二分查找csdn

在初始二分查找的时候,一直以为只有在数组有序的情况才能使用二分查找算法.直到真正接触到二分查找的进阶版本,才知道这个算法的真正所在.此篇文章也结合了我在学习二分算法阶段的一些问题和感悟,包括到底选择哪种二分算法的套路.希望对大家有所帮助!

目录

1.二分查找算法简介:

2.朴素的二分查找

其中有个注意点:对于mid的求值

我们算一下二分查找的时间复杂度:

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

3.1解析:

我们先寻找左端点:

我们再寻找右端点:

3.2题解

3.3总结(重要)

4.搜索插入位置

4.1解析

4.2题解

5. x 的平方根

5.1解析

5.2题解

6.山峰数组的峰顶

6.1解析

6.2题解

7.寻找峰值

7.1解析

7.2题解

8.搜索旋转排序数组中的最小值

8.1题解

9 0~n-1 中缺失的数字

9.1解析

9.2题解

1.二分查找算法简介:

二分查找算法并不是针对在数组有序的情况下,通过后面的题我们就会知道实际上只要是满足"二段性"的题目,都可以通过二分查找算法来实现

我们可以分成三种情况

(1)朴素的二分查找(最简单,但是基本不涉及)

(2)查找左边界的二分查找

(3)查找右边界的二分查找

第二第三基本是万能的,但细节较多

2.朴素的二分查找

题目:. - 力扣（LeetCode）

这种通常出现在查找有序数组的元素

假设数组为 1 2 3 4 5 6 7 8 9 10,如果我们通过暴力解法来是可以的,但是时间复杂度为O(n)

我们使用二分查找来进行优化:

算法流程为:

(1)定义 left ， right 指针，分别指向数组的左右区间。

(2)找到待查找区间的中间点 mid ，找到之后分三种情况讨论：

arr[mid] == target 说明正好找到，返回 mid 的值；

arr[mid] > target 说明 [mid, right] 这段区间都是⼤于 target 的，因此舍去右边区间，在左边 [left, mid -1] 的区间继续查找，即让 right = mid - 1 ，然后重复 2 过程；

arr[mid] < target 说明 [left, mid] 这段区间的值都是⼩于 target 的，因此舍去左边区间，在右边 [mid + 1, right] 区间继续查找，即让 left = mid + 1 ，然后重复 2 过程；

(3当 left 与 right 错开时，说明整个区间都没有这个数，返回 -1

这种朴素的比较简单,我们就直接代码呈现

  1.  public int search(int[] nums, int target) {
  2.          int left = 0,right = nums.length-1;
  3.          while(left <= right){
  4.              int mid = left + (right-left)/2;
  5.              if(nums[mid] < target){
  6.                  left = mid+1;
  7.              }else if(nums[mid] > target){
  8.                  right = mid-1;
  9.              }else{
  10.                  return mid;
  11.              }
  12.          }
  13.          return -1;
  14.      }

其中有个注意点:对于mid的求值

因为left和right一定是在题目提供的数据范围内的,但是`left + right就不一定了

那么我们可以通过 left + (right - left) / 2来计算,通过变换就会发现这个公式实际上和 (left + right )/ 2是一样的,但是没有left+ right,就避免了数据范围操作的风险

实际上求mid的公式有两个,还有一个是left+(right-left+1)/2

当数组元素个数是奇数时:

二者得到的结果没有区别

但是当数组元素个数是偶数的时候:

区别就会出现,但是在朴素二分查找中不会有影响,两个都可以.但是在接下来的两个中就会有很大的影响,如果用错就会造成死循环

我们算一下二分查找的时间复杂度:

假设我们有n个元素,第一次寻找后剩下1/2n个元素,第二次后剩下1/4 n...依次类推,假设寻找了k次,那么最后为 n / 2^k个元素,最坏情况下,最后只剩下1个元素,即 n / 2^k = 1,那么k = log2^N (是以2为底，N的对数)

可能数据量少的时候没有什么很大优势,但是当数据量一大:

差距还是非常明显的
 

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

题目:. - 力扣（LeetCode）

3.1解析:

题目会给我们提供走势类似于下图的数组:

我们主要是查找中间水平阶段的左端点和右端点,

我们先寻找左端点:

通过上图,我们会很容易地看出,左端点将数组划分为左区间和右区间,这不就就是我们在一开始就强调的"二段性",那么我们就可以利用二分查找来寻找这个左端点

但是是朴素的二分查找吗??如果是朴素的二分查找,我们不能保证找到的数是左端点,有可能是水平段之间的任何一个数,那么假设我们根据这个数找左端点,时间复杂度就会回到O(N),那就失去了二分查找的优势

因此我们根据二段性重新分析:

如图所示:左端点把区间分为左边小于8,右边>=8的两部分,那么我们的nums[mid]就会有两种情况:

(1) nums[mid] < target :那么就说明mid落在左边的区域,而左边是不可能存在target,那么我们就要到右边去寻找,所以left就要+1,接着在left到right区间寻找

(2)nums[mid] >= target ,说明我们的mid落在右边区域,但是我们不能单独判断等于,因为我们不知道是不是左端点,所以我们让right = mid,接着在left到right区间寻找

这样,left和right就会向中间靠拢,直到相遇,那么他们的相遇点就是左端点

有以下几个重要的注意点:

((1)循环结束的标志

我们知道,left 和 right相遇的时候就是结束,但是这个相遇这一个点是否要判断呢?我们实验一下

走到这一步时,如果再进行判断,那么mid = 4,满足<= target的条件,那么right = mid;再继续判断,mid还是4,right = mid,那么就会死循环,因此left = right是不需要且不能判断的!

(2)求中点的操作:

我们在上一篇讲到求中点有两个操作,在朴素二分没有区别,但是在这道题就有影响了

如果我们用mid = left + (right-left)/2 公式,left 和 right相遇,循环结束,没有问题

但是如果我们用mid = left + (right-left+1)/2 公式,那么此时mid = 5,right = mid后,死循环了

因此我们只能使用第一种

我们再寻找右端点:

方法和前面的几乎一样,但是

此时我们会发现分成两段区间,左边 <= target,右边 >= target

(1) nums[mid] <= target :那么就说明mid落在左边的区域,而左边是不可能存在target,那么我们就要到右边去寻找,所以left = mid,接着在left到right区间寻找

(2)nums[mid] > target ,说明我们的mid落在右边区域,所以我们让right = mid - 1,接着在left到right区间寻找

这样,left和right就会向中间靠拢,直到相遇,那么他们的相遇点就是左端点

实际上我们会发现与上面的操作是左右颠倒过来的

因此我们计算mid的公式应该用第二个,即left + (right - left + 1)/2

3.2题解
  1.  class Solution {
  2.      public int[] searchRange(int[] nums, int target) {
  3.          if(nums.length == 0){
  4.              return new int[]{-1,-1};
  5.          }
  6.          int begin = -1,end = -1,left = 0,right = nums.length-1;
  7.          while(left < right){
  8.              int mid = left + (right-left)/2;
  9.              if(nums[mid] < target){
  10.                  left = mid+1;
  11.              }else{
  12.                  right = mid;
  13.              }
  14.          }
  15.          if(nums[right] != target){
  16.              return new int[]{-1,-1};
  17.          }else{
  18.              begin = right;
  19.          }
  20.          right = nums.length - 1;
  21.          while(left < right){
  22.               int mid = left + (right-left+1)/2;
  23.              if(nums[mid] <= target){
  24.                  left = mid;
  25.              }else{
  26.                  right = mid - 1;
  27.              }
  28.          }
  29.          end = right;
  30.          return new int[]{begin,end};
  31.      }
  32.  }
3.3总结(重要)

实际上这道题恰恰将我们的二分查找分成查找左边界的二分查找和查找右边界的二分查找

实际上这两种都一样,就看你把端点包含在左区间还是右区间,如果是在左区间,那么说明右边是没有我们要的端点的,那么在移动时就要可以让right = mid -1,而left;如果是在右区间,那么就说明左边是没有我们要的端点的,那么在移动时就是left+1,而right = mid.而计算端点的方法就和要根据你是求左端点还是右端点,依靠不同的方式来求.这里有一个记忆的方法,那就是如果出现right = mid-1,那计算端点就要用left + (right - left + 1)/2.

4.搜索插入位置

题目:. - 力扣（LeetCode）

4.1解析

此题是在寻找小于target的最后一个数的位置或者是等于target的数的位置,那么我们可以根据这个位置把区间划分为两段,左边 < target,右边是>= target,这就是"二段性",就可以利用二分查找的算法来解题.那么端点自然就在右区间了

4.2题解
 
  1. class Solution {
  2.      public int searchInsert(int[] nums, int target) {
  3.          int left = 0,right = nums.length-1;
  4.          while(left < right){
  5.              int mid = left + (right-left)/2;
  6.              if(nums[mid] < target){
  7.                  left = mid+1;
  8.              }else{
  9.                  right = mid;
  10.              }
  11.          }
  12.          if(nums[left] < target){
  13.              return nums.length;
  14.          }
  15.          return right;
  16.      }
  17.  }

5. x 的平方根

5.1解析

假设原数为t,那么我们的暴力解法是从1 ~ t依次枚举,直到找到一个数的平方等于t,或者这个数小于t,下一个数大于t,也是我们要求的

我们同样在暴力解法上进行优化:

如上图所示,还是被分成两个区间,左边 x * x <= target ,右边 x * x > target,即二段性,还是利用二分查找算法,显而易见是寻找端点(端点在左区间)的二分查找

5.2题解
 
  1. class Solution {
  2.      public int mySqrt(int x) {
  3.          if(x == 0){
  4.              return 0;
  5.          }
  6.          long left = 0,right = x;
  7.          while(left < right){
  8.              long mid = left + (right - left+1)/2;
  9.              if(mid*mid <= x){
  10.                  left = mid;
  11.              }else{
  12.                  right = mid-1;
  13.              }
  14.          }
  15.          return (int)right;
  16.      }
  17.  }

6.山峰数组的峰顶

6.1解析

显而易见的二段性,把数组分为两段,左边 的是上升阶段,即 nums[mid] > nums[mid-1]右边阶段是下降阶段,即nums[mid] < nums[mid - 1] .由于我们是判断mid 和 mid - 1的关系,自然时把峰值包含在左区间的

6.2题解
  1.  class Solution {
  2.      public int peakIndexInMountainArray(int[] arr) {
  3.          int left = 1,right = arr.length-2;
  4.          while(left < right){
  5.              int mid = left + (right-left+1)/2;
  6.              if(arr[mid] > arr[mid-1]){
  7.                  left = mid;
  8.              }else{
  9.                  right = mid-1;
  10.              }
  11.          }
  12.          return left;
  13.      }
  14.  }

7.寻找峰值

题目:. - 力扣（LeetCode）

7.1解析

此题与上一题不同的是峰值不止一个,题目说:nums[-1] 和 nums[n] 是负无穷,也就是峰值是一定存在的,哪怕是一个递增(递减)的序列

就会形成类似这样的走势,我们返回其中的一个峰值即可

加上我们在区间中随便找一个点k,那它大致分为两种情况:

(1)nums[k] < nums[k-1],即这个点是在下降区间的,那么这个点的左区间就一定存在峰值,因为nums[-1]是负无穷,那我们就要去左区间找

(2)nums[k] > nums[k-1],即这个点是在上升区间的,那么这个点的右区间就一定存在峰值,因为nums[-1]是负无穷,那我们就要去右区间找

因此又是显然的二段性,由于我们是判断mid 和 mid - 1的关系,自然时把峰值包含在左区间的

7.2题解
 
  1. class Solution {
  2.      public int findPeakElement(int[] nums) {
  3.          int left = 0,right = nums.length - 1;
  4.          while(left < right){
  5.              int mid = left + (right-left+1)/2;
  6.              if(nums[mid] >  nums[mid-1]){
  7.                  left = mid;
  8.              }else{
  9.                  right = mid-1;
  10.              }
  11.          }
  12.          return right;
  13.      }
  14.  }

8.搜索旋转排序数组中的最小值

题目:. - 力扣（LeetCode）

我们直接看最后的数组,会发现,最小的元素会很明显地把数组划分为:

两段蓝色的区间,左边任何一个数都小于nums[n-1] (n是数组长度),那么我们就要去右边找;右边任何一个数都大于等于nums[n-1],但是我们不知道这个值是不是最小值,因此让right = mid,继续把区间往左缩小来找

8.1题解
 
  1. class Solution {
  2.      public int findMin(int[] nums) {
  3.          int n = nums.length;
  4.          int left = 0,right = n-1;
  5.          while(left < right){
  6.              int mid = left + (right-left)/2;
  7.              if(nums[mid] > nums[n-1]){
  8.                  left = mid + 1;
  9.              }else{
  10.                  right = mid;
  11.              }
  12.          }
  13.          return nums[right];
  14.      }
  15.  }

9 0~n-1 中缺失的数字

题目:. - 力扣（LeetCode）

9.1解析

非常明显,左区间所有元素下标是等于对应元素值的,右边则大于;直接二分算法即可!

9.2题解
  1.  public int takeAttendance(int[] records) {
  2.          int left = 0,right = records.length-1;
  3.          while(left < right){
  4.              int mid = left + (right-left)/2;
  5.              if(mid == records[mid]){
  6.                  left = mid + 1;
  7.              }else{
  8.                  right = mid;
  9.              }
  10.          }
  11.          return right == records[right] ? right+1 : right;
  12.      }
  13.  }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/542887?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号