二分查找（基于JDK中的Arrays.binarySearch的实现分析）

一、二分查找动图

二、二分查找思想

1. 前提：数组A是已排序的（默认数组有序）
2. 定义一个左边界left，一个右边界right，确定查找范围，循环执行二分查找（3,4步）
3. 获取中间索引 middle = Floor ( ( left + right ) / 2 )
4. 比较中间索引处的值A[middle]与待查找元素T的大小
   A[middle]==T，表示找到，则返回middle的值；
   A[middle]<T，中间值左侧的所有元素都小于T，无须比较，往中间索引右侧找，则修改左边界middle+1，重新查找；
   A[middle]>T，中间值右侧的所有元素都大于T，无须比较，往中间索引左侧找，则修改右边界 middle-1，重新查找；
5. left>right时，表示没有找到，结束循环
6. 获取中间索引时，如何避免整数溢出（稍后分析）

三、代码实现

/**
 * 二分查找
 */
public class BinarySearch {
    public static void main(String[] args) {
        int[] nums = {1,13,15,24,16,29,30,42,46,49,80,100,120};
        int num = 121;
        System.out.println(binarySearch(nums, num));
    }

    /**
     * @param nums 已排序数组
     * @param t  待查元素
     * @return  找到返回元素索引，未找到返回-1
     */
    public static int binarySearch(int[] nums, int t) {
        int left = 0;//左边界
        int right = nums.length - 1;//右边界
        int middle;//中间索引
        while (left <= right) {
            middle = (left + right) / 2;
            if(nums[middle] == t){
                return middle;
            }else if(nums[middle] < t){
                left = middle+1;
            }else{
                right = middle - 1;
            }
        }
        return -1;
    }
}

四、解决整数溢出问题

1、中间索引值会出现整数溢出的现象

public class IntegerOverFlow {
    public static void main(String[] args) {
        int left = 0;//左边界
        int right = Integer.MAX_VALUE - 1;//右边界

        int middle = (left+right)/2;//中间索引
        System.out.println(middle);

        //右半边找
        left = middle + 1;
        middle = (left+right)/2;
        System.out.println(middle);
    }
}

运行结果：


结果分析：

当数组长度达到最大值时，当在右半边查找元素时，(left+right)/2的结果超出了int的取值范围（-2^31 ---- 2^31-1 ,即：-2147483648 - 2147483647），会变成负数，因而影响程序的运行结果。
补充分析：为什么溢出会导致问题，以byte类型为例：

2、解决整数溢出的方法

方式一：采用数学变换

public class IntegerOverFlow {

    /**
     * middle = (left+right)/2;
     *        = left + (-left/2) + right/2;
     *        = left + (right - left)/2;
     *
     */
    public static void main(String[] args) {
        int left = 0;//左边界
        int right = Integer.MAX_VALUE - 1;//右边界

        int middle = left + (right - left)/2;//中间索引
        System.out.println(middle);

        //右半边找
        left = middle + 1;
        middle = left + (right - left)/2;
        System.out.println(middle);
    }
}

运行结果：

方式二：无符号的右移运算

public class IntegerOverFlow {
    public static void main(String[] args) {
        int left = 0;//左边界
        int right = Integer.MAX_VALUE - 1;//右边界

        int middle = (right + left) >>> 1;//中间索引
        System.out.println(middle);

        //右半边找
        left = middle + 1;
        middle = (right + left) >>> 1;
        System.out.println(middle);
    }
}

运行结果：

原因分析：

五、相关面试题

第一种

给定一个有序数组，并查找某一个元素是否存在，请问该元素需要查找几次草可以查到。
答：对于该类问题，一种是根据二分查找的思想一步一步计算；另一种是根据“奇数二分中间取，偶数二分取中间靠左”的方式快速计算。

第二种

给定一个数组长度length，计算查找某个元素需要比较的次数的数量最多不超过几次。
答：2^n = length 或者 length/2/2·····/2 = 1(除了几次就是最对不超过几次)
问题也可转换为如下图所示：