算法学习之二分查找

二分查找也称折半查找(Binary Search)，一种效率较高的查找算法。要求查找的线性表必须是有序的，关键字有序排序。

1、使用递归。

2、使用循环迭代。

最优时间复杂度O(1)，最差时间复杂度O(log n)。空间复杂度O(1)。

Java代码示例：

    /**
     * 在一个整型数组中查找一个数的所在位置下标
     * @param arr 数组
     * @param key 目标值
     * @param s 数组开始下标位置
     * @param e 数组结束下标位置
     * @return 符合目标值的结果下标
     */
    public int find(int[] arr, int key,int s, int e){
        // 基线条件
        if (s > e){
            return -1;
        }
        //求出中间位置
        int midPos = (e + s)>> 1;
        if (key == arr[midPos]){
            return midPos;
        }else if (key < arr[midPos]){
            return find(arr,key,s,midPos -1);
        }else {
            return find(arr,key,midPos + 1,s);
        }
    }

    /**
     * 支持泛型，引入比较器
     * @param arr 数组
     * @param key 目标对象
     * @param s 数组下标开始位
     * @param e 数组下标结束位
     * @param <T> 泛型
     * @return 目标对象在数组的下标
     */
    public <T extends Comparable<T>> int find(T[] arr, T key, int s, int e){
        //基线条件
        if (s > e){
            return -1;
        }
        //求出中间位置
        int midPos = (s + e) >> 1;
        int cmpResult = key.compareTo(arr[midPos]);
        if (cmpResult == 0){
            return midPos;
        }else if (cmpResult < 0){
            return find(arr, key, s, midPos - 1);
        }else {
            return find(arr, key, midPos + 1, e);
        }
    }

    /**
     * 使用迭代循环二分查找
     * @param arr 数组
     * @param key 目标对象
     * @param s 数组下标开始位
     * @param e 数组下标结束位
     * @param <T> 泛型
     * @return 目标下标位
     */
    public <T extends Comparable<T>> int findCycle(T[] arr, T key, int s, int e){

        while (s >= 0 && e >= s ){
            int midPos = (s + e) >> 1;
            int cmpResult = key.compareTo(arr[midPos]);
            if (cmpResult == 0){
                return midPos;
            }else if (cmpResult < 0){
                e = midPos - 1;
            }else {
                s = midPos + 1;
            }
        }
        return -1;
    }