二分查找-解决整数溢出

一、编写二分查找代码

1. 前提：有已经排好序的数组A

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

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

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

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

2. A[M]>T,中间值右侧的其他元素都大于T，无需比较，到中间索引的左侧去找，M-1设置为右边界

3. A[M]<T,中间值左侧的其他元素都小于T，无需比较，到中间索引的右侧去找，M+1设置为左边界

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

public class BinarySearch {
    public static void main(String[] args) {
        //排好序的数组
        int[] array = {1, 5, 8, 11, 19, 22, 31, 40, 45, 48, 49, 50};
        //目标值
        int target = 48;
        //返回的索引值
        int idx = binarySearch(array, target);
        System.out.println(idx);
    }

    //二分查找算法，找不到索引返回-1
    public static int binarySearch(int[] a, int t) {
        int left = 0; //初始化左边界
        int right = a.length - 1;//初始化右边界
        int mid;//定义中间索引值
        while (left <= right) {
            mid = (left + right) / 2;
            if (a[mid] == t) {
                return mid;
            } else if (a[mid] > t){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        return -1;
    }
}

输出结果：

二、获取中间索引时，如何避免整数溢出？

1. 什么是整数溢出？

1. 整数溢出例子：左边界初始为0，右边界初始为int型最大值，第一次取mid时可以正常输出，第二次取mid时就会发生溢出，如下图

public class IntegerOverflow {
    public static void main(String[] args) {
        int left = 0;
        int right = Integer.MAX_VALUE-1;
        int mid=(left+right)/2;
        System.out.println(mid);
    }
}

第一次取mid

第二次取mid,发生溢出,正整数相加变成了负数

public class IntegerOverflow {
    public static void main(String[] args) {
        int left = 0;
        int right = Integer.MAX_VALUE-1;
        int mid=(left+right)/2;
        System.out.println(mid);

        //在右侧
        left=mid+1;
        mid=(left+right)/2;
        System.out.println(mid);
    }
}

2. 如何解决整数溢出？

1. 方法一：公式变换：left/2 +right/2 => left-left/2+right/2 =>left +(right-left)/2，这样可以保证right除以2不会发生溢出

public class IntegerOverflow {
    public static void main(String[] args) {
        int left = 0;
        int right = Integer.MAX_VALUE-1;
        int mid=left +(right-left)/2;//left/2 +right/2 => left-left/2+right/2 =>left +(right-left)/2
        System.out.println(mid);

        //在右侧
        left=mid+1;
        mid=left +(right-left)/2;
        System.out.println(mid);
    }
}

b. 方法二：右移一位的操作，这种方法不光能解决溢出问题，而且效率上要比除法高，因为CPU在处理移位运算所消耗的时钟周期比做除法小号的时钟周期短

public class IntegerOverflow {
    public static void main(String[] args) {
        int left = 0;
        int right = Integer.MAX_VALUE-1;
        int mid=(right-left)>>>1;
        System.out.println(mid);

        //在右侧
        left=mid+1;
        mid=(right-left)>>>1;
        System.out.println(mid);
    }
}

结果没有溢出