面试：java 二分查找

**算法描述**

1. 前提：有已排序数组 A（假设已经做好）

2. 定义左边界 L、右边界 R，确定搜索范围，循环执行二分查找（3、4两步）

3. 获取中间索引 M = Floor((L+R) /2)

4. 中间索引的值  A[M] 与待搜索的值 T 进行比较

   ① A[M] == T 表示找到，返回中间索引

   ② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找

   ③ A[M] < T，中间值左侧的其它元素都小于 T，无需比较，中间索引右边去找， M + 1 设置为左边界，重新查找

5. 当 L > R 时，表示没有找到，应结束循环

**算法实现**

public class Test2 {

    public static void main(String[] args) {
        int[] array = {1, 5, 8, 11, 19, 22, 25, 28, 31, 35, 40, 43, 45, 48, 49, 50, 51, 57, 63};
        int target = 51;
        int idx = binarySearch(array, target);
        System.out.println(idx);
    }

    public static int binarySearch(int[] a, int t) {
        int l = 0, r = a.length - 1, m;
        while (l <= r) {
            m = (l + r) / 2;
            if (a[m] == t) {
                return m;
            } else if (a[m] > t) {
                // 目标范围在左侧，重置右边界
                r = m - 1;
            } else {
                // 目标范围在右侧，重置左边界
                l = m + 1;
            }
        }
        return -1;
    }

}

整数溢出问题：当 l + r 的值很大，超过整数范围

    public static void main(String[] args) {
        int l = 0;
        int r = Integer.MAX_VALUE;

        // 第一次比较
        int m = (l + r) / 2;

        System.out.println(m);

        // 假如目标范围在右侧，重置左边界
        // 第二次比较
        l = m + 1;
        m = (l + r) / 2;

        System.out.println(m);
    }


    控制台输出：
    1073741823
    -536870912

 解决方法1：改变数学公式

int m = (l + r) / 2 
	  = l/2 + r/2
	  = l - l/2 + r/2
	  = l + (r/2 - l/2)
	  = l + (r - l) / 2

 代码修改为：

    public static void main(String[] args) {
        int l = 0;
        int r = Integer.MAX_VALUE;

        // 第一次比较
        // int m = (l + r) / 2;
        int m = l + (r - l) / 2;

        System.out.println(m);

        // 假如目标范围在右侧，重置左边界
        // 第二次比较
        l = m + 1;
        // m = (l + r) / 2;
        m = l + (r - l) / 2;

        System.out.println(m);
    }
    
    控制台输出：
    1073741823
    1610612735

解决方法2：右移运算

    public static void main(String[] args) {
        int l = 0;
        int r = Integer.MAX_VALUE;

        // 第一次比较
        // int m = (l + r) / 2;
        // int m = l + (r - l) / 2;
        int m = (l + r) >>> 1;

        System.out.println(m);

        // 假如目标范围在右侧，重置左边界
        // 第二次比较
        l = m + 1;
        // m = (l + r) / 2;
        // m = l + (r - l) / 2;
        m = (l + r) >>> 1;

        System.out.println(m);
    }

    控制台输出：
    1073741823
    1610612735

建议使用位移运算；

**其它考法**

1. 有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数 

 2. 使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（   ）次比较

对于前两个题目，记得一个简要判断口诀：奇数二分取中间，偶数二分取中间靠左。

3. 在拥有128个元素的数组中二分查找一个数，需要比较的次数最多不超过多少次

128/2=64/2=32/2=16/2=8/2=4/2=2/2=1

2的7次方 = 128

扩展题目，一个数组，有40亿个元素，最多需要比较几次

使用计算器计算，但是计算器使用的是10进制

 即10的3次方 = 1000

有个公式可以转换：

 那么计算128是2的多少次方

那么，40亿是2的多少次方

 即，一个数组，有40亿个元素，二分查找，最多需要比较32次