【数据结构】你不知道的“二分查找”

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

2. 如何快速定位IP对应的省份地址

如果IP区间与归属地的对应关系不经常更新，我们可以先预处理这12万条数据，让其按照起始IP从小到大排序。如何来排序呢？我们知道，IP地址可以转化为32位的整型数。所以，我们可以将起始地址，按照对应的整型值的大小关系，从小到大进行排序。

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

喜欢本文的话，可以关注一下公众号，每天定时更新一篇学习日记，让我们一起成长！