二分查找

二分查找算法

二分查找算法的核心就是在查找的一堆有序数据中，使用\(\log_n\)的时间复杂度进行查找，最基本的算法代码如下：

    public static int binarySearch(int[] a, int target) {
        if (a.length == 0) return -1;
        int low = 0, high = a.length - 1;   // 设置左右指针

        while(low <= high) {
            int mid = (low + high) /2;
            if(a[mid] == target) return mid;
            else if(a[mid] < target) low = mid +1;  // 目标在中间值的右边，范围应该往大的靠近
            else high = mid - 1;    // 目标在中间值的左边，范围应该往小的靠近
        }
        return -1;
    }

现在呢，有几个问题值得我们思考一下：

1. 为什么在while循环里是low <= high，而不是low < hogh呢？

这是因为在待查找的数组元素个数是偶数，但要查找的元素恰好是第一个元素或者最后一个元素是，最后一步while条件中 low 指针 = high 指针，此时while条件是low < hign，就不会满足这个条件，从而退出循环！(也就是少做了一次比较，low 和 high 指针的值也是要考虑比较的)

这里给出错误的 while 条件判断代码以及测试数据:

    public static int binarySearch(int[] a, int target) {
        if (a.length == 0) return -1;
        int low = 0, high = a.length - 1;   // 设置左右指针

        while(low < high) {
            int mid = (low + high) /2;
            if(a[mid] == target) return mid;
            else if(a[mid] < target) low = mid +1;  // 目标在中间值的右边，范围应该往大的靠近
            else high = mid - 1;    // 目标在中间值的左边，范围应该往小的靠近
        }
        return -1;
    }

	public static void main(String[] args) {
        int index = binarySearch(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 1);
        System.out.println(index);
    }

测试结果如下：

-1

2. 在使用 mid = (low + hogh) / 2求中间元素时有没有问题？

当然是有问题的！如果元素个数非常大时，在计算时可能会引发正整数溢出的情况，看下下面的代码：

    public static void main(String[] args) {
        int i = 0, j = Integer.MAX_VALUE;
        int mid = (i + j) / 2;
        System.out.println(mid);    // 1073741823
        System.out.println((mid + j) / 2);	// -1073741823
    }

我们发现在第二个输出是一个负数？索引怎么可能是一个负数呢？这里肯定是不对的！原因就是两个很大的正整数相加就会超过正整数所能表示的范围！这时候再除2也没什么用了。

这里再简单的聊几句：在JAVA语言中，没有所谓的无符号整数这个概念，整数在Java里都是有符号整数，而数据是通过二进制表示的，其中最高位是符号为，最高位为0表示的是正数，最高位为1表示的是负数，因此两个非常大的正整数相加时，两个数的二进制表示中，最高位的下一位相加会引发进位，因此符号为就成了0+0+1=1，因此就表示成了负数，这也就是造成了正整数溢出！

那么我们如何保证两个非常大的数字相加不造成溢出呢？其实很简单，我们换成无符号右移运算符>>>来解决问题。

这里举个例子：

二进制：1011_1111_1111_1111_1111_1111_1111_1110
不把最高位作为无符号位表示就是：32221225470

把最高位作为有符号位表示就是：-1073741826

把二进制向右无符号移动一位：0101_1111_1111_1111_1111_1111_1111_1111 表示的就是1610612735，刚好是正确的值！

当然了，除了无符号逻辑右移运算能够避免溢出的情况外，还有一种写法也能避免溢出：

mid = left + (right - left) /2;

具体用哪种写法，大家自行选择！

接下来我们再看下 JAVA 中对于二分查找的实现源码：

 private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

我们发现了一个问题：就是当要查找的元素不存在的时候会返回 -(low + 1)，这是什么意思呢？

我么通过阅读源代码诸事发现，返回的值 = -（插入点 - 1）==> -插入点 = 返回值 - 1

也就是说，如果要查找的元素不存在，则这个元素如果想插入到这个数组中，则插入的索引位置为返回值+1 再取绝对值。

有兴趣的可以去看看源代码，这里就不再过多赘述了。