你不知道的“二分查找”

Posted 2021-04-24 evan波的打卡日记

二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为0。

普通版代码实现：

public static int binarySearch(int[] arr,int num){ int left = 0; int right = arr.length - 1; while (left <= right){ //防止两者之后导致类型值溢出 int mid = left + ((right - left) >> 1); if (arr[mid] == num){ return mid; }else if (arr[mid] > num){ right = mid - 1; }else { left = mid + 1; } } return -1;}

容易出错的几个地方：

1. 循环的条件，注意是left <= right，而不是left < right
   

2. mid的取值，尽量少用mid = (left + right) / 2，当值比较大时，容易导致值溢出，可以使用 mid = left + ((right - left) >> 1)

3. low和high的更新，一般low = mid + 1，high = mid - 1;
   

递归实现：

public static int binarySearch1(int[] arr, int value){ return binarySearchInternally(arr,0,arr.length - 1,value);}
private static int binarySearchInternally(int[] arr,int low,int high,int value){ if (low > high) return -1; //防止类型值溢出 int mid = low + ((high - low) >> 1); if (arr[mid] == value){ return mid; }else if (arr[mid] > value){ return binarySearchInternally(arr,low, mid - 1,value); }else { return binarySearchInternally(arr,mid + 1,high,value); }}

二分查找局限性：

1. 二分查找依赖的是顺序表结构，即数组
   

2. 二分查找需要是有序数据

3. 数据量太小或太大，都不适合用二分查找。太小，普通查找效率不一定比二分查找低，太大，很难找到连续的内存空间。

二分查找的多种情况

1. 查找第一个给定值的元素

即上述两种方法，即可解决

2. 查找最后一个值等于给定值的元素

public static int binarySearch2(int[] arr,int num){ int left = 0; int right = arr.length - 1; while (left <= right){ //防止两者之后导致类型值溢出 int mid = left + ((right - left) >> 1); if (arr[mid] > num){ right = mid - 1; }else if (arr[mid] < num){ left = mid + 1; }else { if ((mid == arr.length - 1) || (arr[mid + 1] != num)){ return mid; }else { left = mid + 1; } } } return -1;}

如果arr[mid]这个元素已经是数组中的最后一个元素了，那它肯定是我们要找的；如果arr[mid]的后一个元素arr[mid+1]不等于num，那也说明arr[mid]就是我们要找的最后一个值等于给定值的元素。

3. 查找第一个大于等于给定值的元素

比如，数组中存储的这样一个序列：3，4，6，7，10。如果查找第一个大于等于5的元素，那就是6。

思路：

如果arr[mid]小于要查找的值num，那要查找的值肯定在[mid+1, right]之间，所以，更新left=mid+1。

对于arr[mid]大于等于给定值num的情况，要先看下这个arr[mid]是不是我们要找的第一个值大于等于给定值的元素。如果arr[mid]前面已经没有元素，或者前面一个元素小于要查找的值num，那arr[mid]就是要找的元素。

public static int binarySearch3(int[] arr,int num){ int left = 0; int right = arr.length - 1; while (left <= right){ //防止两者之后导致类型值溢出 int mid = left + ((right - left) >> 1); if (arr[mid] >= num){ if (mid == 0 || arr[mid - 1] < num){ return mid; } right = mid - 1; }else { left = mid + 1; } } return -1;}

4. 查找最后一个小于等于给定值的元素

第四种情况和第三个情况相反

当arr[mid] > num时，意味着数据在[left, mid - 1]之间,right = mid - 1即可；

当arr[mid] <= num时，要先看下这个arr[mid]是不是我们要找的最后一个小于等于给定值的元素。如果arr[mid]后面已经没有元素，或者后面一个元素大于要查找的值num，那arr[mid]就是要找的元素。

代码实现：

public static int binarySearch4(int[] arr,int num){ int left = 0; int right = arr.length - 1; while (left <= right){ //防止两者之后导致类型值溢出 int mid = left + ((right - left) >> 1); if (arr[mid] > num){ right = mid - 1; }else { if (mid == arr.length - 1 || arr[mid + 1] > num){ return mid; } left = mid + 1; } } return -1;}

二分查找的应用：

1.如何编程实现“求一个数的平方根”？要精确到小数点后6位

public static double sqrt(double x , double precision){ if (x < 0){ return Double.NaN; } double low = 0; double high = x; if (x < 1 && x > 0){ low = x; high = 1; } double mid = low + (high - low) / 2; while (high - low > precision){ if (mid * mid > x){ high = mid; }else if (mid * mid < x){ low = mid; }else { return mid; } mid = low + (high - low) / 2; } return mid;}

然后问题就是今天提到的二分查找第四种情况。当我们要查询某个IP归属地时，我们可以先通过二分查找，找到最后一个起始IP小于等于这个IP的IP区间，然后，检查这个IP是否在这个IP区间内，如果在，我们就取出对应的归属地显示；如果不在，就返回未查找到。