二分查找（折半查找）

一、什么是二分查找

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列

二、算法复杂度

二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.

时间复杂度即是while循环的次数。

总共有n个元素，

渐渐跟下去就是n,n/2,n/4,....n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数

由于你n/2^k取整后>=1

即令n/2^k=1

可得k=log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O(h)=O(log2n)

三、如何理解二分查找

给定范围0到1000的整数：

第一次我们选择500，发现偏大了，

那么下一次的选择范围，就变成了1到499：

第二次我们选择250，发现还是偏大了，

那么下一次的选择范围，就变成了1到249：

第三次我们选择125，发现偏小了，

那么下一次的选择范围，就变成了126到249：

以此类推，最坏的情况需要猜测多少次呢？

答案是 log1000 = 10次，

也就是让原本的区间范围进行10次 “折半”。

四、代码实现

1.非递归方式

import java.util.Arrays;

public class test07 {
    public static void main(String[] args) {
        int[] arr = new int[]{15,66,48,9,54,11,87,100,40,8,9,7,12,13};
        int key = 11;  //要查找的数
        Arrays.sort(arr);  //二分查找，之前一定要对数组进行元素排序
        System.out.println(Arrays.toString(arr));   //打印数组
        System.out.println(key+"元素的索引"+binarySearch(arr,key));
    }
    public static int binarySearch(int[] array,int key){
        //头指针初始位置
        int low = 0;
        //尾指针初始位置
        int high = array.length - 1;
        //判断查找的数是否在数组中，如果此处不加判断，则可能报java.lang.StackOverflowError栈内存溢出
        if(low>high||key>array[high]||key<array[low]){
            return -1;
        }
        while(low<=high){
            //计算中间值的索引，防止溢出
            int mid = low+ (high - low)/2;
            if(key==array[mid]){
                return mid;    //返回查询到的索引位置
            }else if (key>array[mid]){
                low = mid+1; //mid所对应的的值比key小，key应该在右边
            }else {
                high = mid-1;  //mid所对应的的值比key大，key应该在左边
            }
        }
        //若没有，则返回-1
        return -1;
    }
}

2.非递归方式

import java.lang.annotation.ElementType;
import java.util.Arrays;

public class test07 {
    public static void main(String[] args) {
        int[] arr = new int[]{15,66,48,9,54,11,87,100,40,8,9,7,12,13};
        int key = 11;  //要查找的数
        //头指针初始位置
        int low = 0;
        //尾指针初始位置
        int high = arr.length - 1;
        Arrays.sort(arr);  //二分查找，之前一定要对数组进行元素排序
        System.out.println(Arrays.toString(arr));   //打印数组
        System.out.println(key+"元素的索引"+binarySearch(arr,low,high,key));
    }
    public static int binarySearch(int[] array,int low,int high,int key){
        //判断查找的数是否在数组中，如果此处不加判断，则可能报java.lang.StackOverflowError栈内存溢出
        if(low>high||key>array[high]||key<array[low]){
            return -1;
        }
        //计算中间值的索引，防止溢出
        int mid = low+ (high - low)/2;
        if (key>array[mid]){
            return binarySearch(array,mid+1,high,key);     //mid所对应的的值比key小，key应该在右边
        }else if(key<array[mid]){
            return binarySearch(array,low,mid-1,key); //mid所对应的的值比key大，key应该在左边
        }else{
            return mid;
        }
    }
}

二分查找中值(mid)计算 二分查找中值计算有三种方式：

• int mid = (low + high)/ 2;
• int mid = low + (high - low) / 2;
• int mid = (high + low) >>> 1
• 上述两种算法看似第一种要简洁，第二种提取之后，跟第一种没有什么区别。但是实际上上述两种计算是有区别的，
• 第一种的做法是在极端情况下计算的，(low + high)存在着溢出的风险，进而有可能得到错误的mid结果，导致程序错误；
• 而第二种算法能够保证计算出来的mid值一定大于low、小于high，不存在溢出的问题。
• 针对第一种算法为了防止溢出问题，可以使用：int mid = (high + low) >>> 1; 解决此问题。

五、二分查找的优缺点：

优点：比较次数少，查找速度快，平均性能好。

缺点：必须有序，必须是数组。