查找之二 ， 二分查找

二分查找的思想是：对一个非空的有序的查找表进行如下比较（以下假设是升序排列）：

查找找表的低位 low ， 高位 high ，

如果 middle = (low + high) / 2 的值等于key值，则查找成功；

如果 middle的值小于key的值，说明key可能在后半段，low=middle ；

如果 middle的值大于key的值， 说明key可能在前半段， high = low ；

直到low >= high表明查找失败。

下面是二分查找的Java实现版（非递归实现）：

public static int binSearch(int[] src, int key) {
        if (src == null || src.length == 0)
            return -1;
        int low = 0, high = src.length, middle;
        while (low < high) {
            middle = (low + high) >> 1;
            if (src[middle] == key)
                return middle;
            else if (src[middle] < key)
                low = middle;
            else if (src[middle] > key)
                high = middle;
        }
        return -1;
    }

二分搜索的递归方法实现：

public static int binSearchRecursive(int[] src, int key) {
        if (src == null || src.length == 0)
            return -1;
        return binSearchRecursive(src, key, 0, src.length);
    }

    private static int binSearchRecursive(int[] src, int key, int low, int high) {
        if (low >= high)
            return -1;
        int middle = (low + high) >> 1;
        if (src[middle] == key)
            return middle;
        else if (src[middle] < key)
            return binSearchRecursive(src, key, middle, high);
        else if (src[middle] > key)
            return binSearchRecursive(src, key, low, middle);
        return -1;
    }

测试数据：

public static int[] DATA_COLLECTION = {
            1, 2, 7, 24, 30, 45, 46, 78, 234, 567, 888, 987, 1000
    };

    public static void main(String[] args) {
        System.out.println(binSearch(DATA_COLLECTION, 888));
        System.out.println(binSearchRecursive(DATA_COLLECTION, 888));
    }

该算法时间复杂度，对于任意长度的查找表，每次检查后查找区间都缩小一半，所以O（N）=log n 。

下一篇 块查找。