devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

二分算法（java超详细）_二分查找java

作者：小丑西瓜9 | 2024-04-28 13:41:40

赞

踩

二分查找java

一、二分查找

1. 整数二分

二分查找：也称折半搜索，对数搜索，是用来在一个有序数组中查找某一元素的算法。

例子：在一个升序数组中查找一个数。每次考察数组当前部分的中间元素（middle），如果中间元素刚好是目标元素(target)，就结束搜索。如果中间元素小于所查找的值，就在数组左半部分[left,middle]查找；如果中间元素大于所查找的值，就在数组右半部分[middle,right]查找。

二分搜索法可以用来查找满足某一条件的最大（最小）值。

要求满足某种条件的最大值最小可能情况（最大值最小化），首先的想法是从小到大枚举这个作为答案的[最大值]，然后去判断是否合法。若答案单调，就可以使用二分搜索法来更快的找到答案

使用二分搜索法解决[最大值最小化]条件：

  1. 答案在一个固定区间内

  2. 比较容易判断某个值是否符合条件

  3. 可行解对于区间满足一定的单调性（x符合条件，那么x-1或x+1也符合条件）

  • 时间复杂度：最优情况O(1)，平均/最坏时间复杂度O(log n)

1.1 二分查找算法模板1

算法思路

假设目标值在闭区间[l,r]中，每次将区间长度缩小一半，当l=mid时，找到目标值

区间[l,r]划分为[l,mid-1]和[mid+1,r];更新操作为r=mid-1或l=mid+1。

  1. int binarySearch(int[] nums, int target){
  2.   if(nums == null || nums.length == 0){ //数组为空
  3.     return -1;
  4.   }
  5.   int l = 0, r = nums.length - 1; //设置左右边界
  6.   while(l <= r){ 
  7.     int mid = l + (r-l) / 2; // 等同于mid=(l+r)/2,这种写法是为了防止数组越界,也可以写为(l+r) >>> 1
  8.     if(nums[mid] == target){ //最终target=mid,输出mid
  9.         return mid; 
  10.     }else if(nums[mid] < target) { //目标值在(mid,r]之间
  11.         l = mid + 1; 
  12.     }else {  //目标值在[l,mid)之间
  13.         r = mid - 1; 
  14.     }
  15.   }
  16.   // 最后判断: l>r 即数组不存在
  17.   return -1;
  18. }

1.2 二分查找算法模板2

算法思路

假设目标值在闭区间[l,r]中，每次将区间长度缩小一半，当l=left时，找到目标值

区间[l,r]划分为[l,mid]和[mid+1,r];更新操作为r=mid或l=mid+1(与模板一的区别是界限不同)

  1. int binarySearch(int[] nums, int target){
  2.   if(nums == null || nums.length == 0){ //数组为空
  3.     return -1;
  4.   }
  5.   int l = 0, r = nums.length - 1; //设置左右边界
  6.   while(l <= r){ 
  7.     int mid = l + (r-l) / 2; 
  8.     if(nums[mid] > target) {  //目标值在[l,mid]之间
  9.         r = mid; 
  10.     }else if(nums[mid] < target){
  11.         l = mid+1;
  12.     }else{
  13.         r = mid;
  14.     }
  15.   }
  16.   if(nums[l] == target){
  17.       return l; //当l=left时，找到目标值的下标
  18.   }
  19.   return -1;
  20. }

1.3 二分查找算法模板3

算法思路

假设目标值在闭区间[l,r]中，每次将区间长度缩小一半，当l=right时，找到目标值

区间[l,r]划分为[l,mid-1]和[mid,r];更新操作为r=mid-1或l=mid(与模板一的区别是界限不同)

  1. int binarySearch(int[] nums, int target){
  2.   if(nums == null || nums.length == 0){ //数组为空
  3.     return -1;
  4.   }
  5.   int l = 0, r = nums.length - 1; //设置左右边界
  6.   while(l <= r){ 
  7.     int mid = (l+r+1) / 2; //这种版本会有边界问题，计算mid要加1
  8.     if(nums[mid] > target) {  //目标值在[l,mid]之间
  9.         r = mid-1; 
  10.     }else if(nums[mid] < target){
  11.         l = mid;
  12.     }else{
  13.         r=mid-1;
  14.     }
  15.   }
  16.   if(nums[r] == target){
  17.       return r; //当l=right时，找到目标值的下标
  18.   }
  19.   return -1;
  20. }

1.4 二分查找算法模板4

关于开闭区间问题

二分查找 [left, right)

  • 用于查找需要访问数组中当前索引及其直接右邻居索引的元素或条件。

  • 使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。

  • 保证查找空间在每一步中至少有 2 个元素。

  • 需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件。

  1. // 二分查找 [left, right)
  2.     int binarySearch2(int[] nums, int target){
  3.         if(nums == null || nums.length == 0)
  4.             return -1;
  5.         // 定义target在左闭右开的区间里，即：[left, right)
  6.         int left = 0, right = nums.length;
  7.         // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
  8.         while(left < right){
  9.             int mid = left + (right - left) / 2;
  10.             if(nums[mid] == target){
  11.                 return mid;
  12.             }
  13.             else if(nums[mid] < target) {
  14.                 //  target 在右区间，在[mid + 1, right)中
  15.                 left = mid + 1;
  16.             }
  17.             else {
  18.                 // target 在左区间，在[left, middle)中
  19.                 right = mid;
  20.             }
  21.         }
  22.         //当 left == right
  23.         if(left != nums.length && nums[left] == target) return left;
  24.         return -1;
  25.     }

1.5 二分查找算法模板5

二分查找 (left, right)

搜索需要访问当前索引及其在数组中的直接左右邻居索引的元素或条件。

  • 搜索条件需要访问元素的直接左右邻居。

  • 使用元素的邻居来确定它是向右还是向左。

  • 保证查找空间在每个步骤中至少有 3 个元素。

  • 需要进行后处理。 当剩下 2 个元素时，循环 / 递归结束。 需要评估其余元素是否符合条件。

  1.  // 二分查找 (left, right)
  2.     int binarySearch3(int[] nums, int target) {
  3.         if (nums == null || nums.length == 0)
  4.             return -1;
  5.  
  6.         int left = 0, right = nums.length - 1;
  7.         while (left + 1 < right){
  8.             int mid = left + (right - left) / 2;
  9.             if (nums[mid] == target) {
  10.                 return mid;
  11.             } else if (nums[mid] < target) {
  12.                 //  target 在右区间，在(middle, right)中
  13.                 left = mid;
  14.             } else {
  15.                 // target 在左区间，在(left, middle)中
  16.                 right = mid;
  17.             }
  18.         }
  19.         // 当: left + 1 == right
  20.         if(nums[left] == target) return left;
  21.         if(nums[right] == target) return right;
  22.         return -1;
  23.     }

关于模板中出现的边界问题

更新之后的mid仍然为L，左右边界没有发生变化，会使while陷入死循环，所以求mid=(r+l+1)/2

练习题目+详解

练习题1

 

思路

思路也很简单，就是用二分法找到每一个数字的下标，这里要注意，我们需要找到每个元素第一次出现的位置，所以需要设置l<r，然后递归的时候r=mid, 这样如果目标值存在的话，就返回l的位置。

代码

  1. public class 二分查找 {
  2.     static int a[] = new int[10^6+10]; //定义一个数组a的全局变量
  3.     static int binarySearch(int x, int n) { //x是目标值，n是数组长度
  4.         int l = 0; int r = n-1 ;
  5.         while (l<r){
  6.             int mid = (l+r)/2;
  7.             if(a[mid] < x) l = mid+1;
  8.             else r = mid;
  9.             
  10.         }
  11.         //找到目标值，返回下标
  12.         if(a[l] == x) return l+1; //注意：从1开始编号
  13.         else return -1;
  14.  
  15.     }
  16.     public static void main(String[] args) {
  17.         Scanner sc = new Scanner(System.in);
  18.         //用户输入n,m 分别代表数组长度,询问次数
  19.         int n = sc.nextInt(), m = sc.nextInt();
  20.         //这里读入数组
  21.         for(int i = 0; i < n; i++){
  22.             a[i] = sc.nextInt();
  23.         }
  24.  
  25.         //挨个找数字的下标
  26.         for(int i = 0; i < m; i++){
  27.             int q = sc.nextInt();
  28.             int ans = binarySearch(q, n);
  29.             System.out.print(ans + " ");
  30.         }
  31.     }
  32. }

练习题2

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

思路

直观的思路肯定是从前往后遍历一遍。用两个变量记录第一次和最后一次遇见 target 的下标，但这个方法的时间复杂度为 O(n)，没有利用到数组升序排列的条件。由于数组已经排序，因此整个数组是单调递增的，我们可以利用二分法来加速查找的过程。

考虑 target 开始和结束位置，其实我们要找的就是数组中「第一个等于 target 的位置」（记为 left）和「第一个大于 target 的位置减一」（记为 right）。

二分查找中，寻找 left 即为在数组中寻找第一个等于 target 的下标，寻找 right 即为在数组中寻找第一个大于 target 的下标，然后将下标减一。两者的判断条件不同，为了代码的复用，我们定义 searchRange(nums,target) 表示在 nums数组中二分查找 target 的位置 。

最后，因为 target可能不存在数组中，因此我们需要重新校验我们得到的两个下标 left 和 right，看是否符合条件，不符合就返回 -1,-1。

  1.  
  2. public class 查找下标 {
  3.  
  4.     public int[] searchRange(int[] nums, int target){
  5.         int len = nums.length;
  6.         if(len == 0){
  7.             return new int[]{-1,-1};
  8.         }
  9.  
  10.         int firstPosition = findFirstPosition(nums,target);
  11.         if(firstPosition == -1){
  12.             return new int[]{-1,-1};
  13.         }
  14.  
  15.         int lastPositon = findLastPosition(nums,target);
  16.         return new int[]{firstPosition,lastPositon};
  17.     }
  18.  
  19.     private int findFirstPosition(int[] nums, int target){
  20.  
  21.         int left = 0;
  22.         int right = nums.length-1;
  23.         while(left < right){ //这里没有包含left=right的情况
  24.             int mid = (left+right)/2;
  25.             if(nums[mid] < target){
  26.                 //在[mid+1,right]之间找
  27.                 left = mid+1;
  28.             }else if(nums[mid] > target){
  29.                 //在[ledt,mid-1]之间找
  30.                 right = mid-1;
  31.             }else{
  32.                 //在[left,mid]之间找
  33.                 right = mid;
  34.             }
  35.         }
  36.         if(nums[left] == target){
  37.             return left;
  38.         }
  39.         return -1;
  40.     }
  41.  
  42.     private int findLastPosition(int[] nums, int target){
  43.  
  44.         int left = 0;
  45.         int right = nums.length-1;
  46.         while(left < right){ //这里没有包含left=right的情况
  47.             int mid = (left+right+1)/2;
  48.             if(nums[mid] < target){
  49.                 //在[mid+1,right]之间找
  50.                 left = mid+1;
  51.             }else if(nums[mid] > target){
  52.                 //在[ledt,mid-1]之间找
  53.                 right = mid-1;
  54.             }else{
  55.                 //在[mid，right]之间找
  56.                 left = mid;
  57.             }
  58.         }
  59.         return left;
  60.     }
  61. }
  • >>表示右移，如果该数为正，则高位补0，若为负数，则高位补1；
  • >>>表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0。
  • 时间复杂度：O（log n）

练习题3

整数数组 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) 的算法解决此问题。

思路

这道题中，数组本身不是有序的，进行旋转后只保证了数组的局部是有序的，这还能进行二分查找吗？答案是可以的。可以发现的是，我们将数组从中间分开成左右两部分的时候，一定有一部分的数组是有序的。拿示例来看，我们从 6 这个位置分开以后数组变成了 [4, 5, 6] 和 [7, 0, 1, 2] 两个部分，其中左边 [4, 5, 6] 这个部分的数组是有序的，其他也是如此。这启示我们可以在常规二分查找的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid] 和 [mid + 1, r] 哪个部分是有序的，并根据有序的那个部分确定我们该如何改变二分查找的上下界，因为我们能够根据有序的那部分判断出 target 在不在这个部分：

  • 如果 [l, mid - 1] 是有序数组，且 target 的大小满足[nums[l],nums[mid]，则我们应该将搜索范围缩小至 [l, mid - 1]，否则在 [mid + 1, r] 中寻找。

  • 如果 [mid, r] 是有序数组，且 target 的大小满足 [nums[mid+1],nums[r]]，则我们应该将搜索范围缩小至 [mid + 1, r]，否则在 [l, mid - 1] 中寻找。

需要注意的是，二分的写法有很多种，所以在判断 target 大小与有序部分的关系的时候可能会出现细节上的差别。

  1. public class 螺旋数组 {
  2.     public int search(int[] nums, int target) {
  3.         int n = nums.length;
  4.         if (n == 0) {
  5.             return -1;
  6.         }
  7.         if (n == 1) {
  8.             return nums[0] == target ? 0 : -1;
  9.         }
  10.         int l = 0, r = n - 1;
  11.         while (l <= r) {
  12.             int mid = (l + r) / 2;
  13.             if (nums[mid] == target) {
  14.                 return mid;
  15.             }
  16.             if (nums[0] <= nums[mid]) { //如果左边是有序的
  17.                 if (nums[0] <= target && target < nums[mid]) {//目标值在左边
  18.                     r = mid - 1;
  19.                 } else { //如果目标值在右边
  20.                     l = mid + 1;
  21.                 }
  22.             } else { //如果左边是无序的，就相当于遍历该区间元素了
  23.                 if (nums[mid] < target && target <= nums[n - 1]) {//目标值在右边
  24.                     l = mid + 1;
  25.                 } else {
  26.                     r = mid - 1;
  27.                 }
  28.             }
  29.         }
  30.         return -1;
  31.     }
  32. }

复杂度分析

  • 时间复杂度： O(log⁡n)，其中 n 为nums 数组的大小。整个算法时间复杂度即为二分查找的时间复杂度 O(logn)。

  • 空间复杂度： O(1) 。我们只需要常数级别的空间存放变量。

2. 浮点数二分

浮点数二分：将整数二分中的mid的类型替换成double，将区间更新操作改为l=mid或r=mid，当区间长度足够小（能求出答案时），就可以结束二分。注：浮点数二分不存在边界问题。

代码示例

  1. double binarySearch(int[] nums,int target){
  2. 	// eps 表示精度，取决于题目对精度的要求
  3.     double l = 0; double r = nums.length-1;
  4.     const double eps = 1e-6; //科学计数法1*10^-6 当区间长度小于eps时退出循环 
  5.     while (r - l > eps){ //当区间长度大于eps时继续二分
  6.         double mid = (l + r) / 2;
  7.         if (nums[mid] > target ) r = mid;
  8.         else l = mid;
  9.     }
  10.     return l; //最后while循环退出的时候l和r近似相等
  11. }

总结

这里对文章进行总结：
        以上就是整理的二分算法的内容，本文仅仅简单介绍了二分算法，而要在具体的题目中真正掌握运用二分算法，还需要多加练习二分算法的各种题目。

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

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

  

闽ICP备14008679号