java实现二分查找-递归和非递归

二分查找算法思想

有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功。

一个情景：将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

二分查找的使用条件

数组必须为有序数组，
比较次数少，查询快

代码实现

非递归实现

 /**
     * 非递归二分查找
     * @param arr 有序数组
     * @return
     */
    public static int BinarySearch1(int key,int[] arr){
        int low = 0;
        int high = arr.length-1;
        //中间值
        int middle;
        //先做一些简单的判断
        if(key<arr[low]||key>arr[high]){
            return -1;
        }
        //进入循环
        while (low<=high){
            //细节防止溢出 书写好习惯
            // 相当于（low+high）除以2
            middle = low +(high-low)/2;

            if(key<arr[middle]){
                //比关键字小则关键字在左区域
                high = middle-1;
            }
            else if(key>arr[middle]){
                //比关键字大则关键字在左区域
                low = middle+1;
            }
            else {
                return middle;
            }
        }
        return -1;
    }

递归实现

 /**
     *递归实现二分查找
     * @param key
     * @param arr
     * @return
     */
     public static int BinarySearch2(int key,int[] arr){
        int low = 0;
        int high = arr.length-1;
        return BinarySearchHelper(low,high,arr,key);


    }

    public static int BinarySearchHelper(int low,int high,int[]arr,int key){
        int middle;
        middle = low +(high-low)/2;

        //递归结束的标志
        if(key < arr[low] || key > arr[high]){
            return -1;
        }else {

            if(key<arr[middle]){
                return BinarySearchHelper(low,middle-1,arr,key);
            }
            else if(key>arr[middle]){
                return BinarySearchHelper(middle+1,high,arr,key);
            }
            else {
                return middle;
            }
        }



    }

测试代码

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

复杂度分析

采用的是分治策略
时间复杂度O(logN) 最好是O（1）
空间复杂度 递归 O(logN) 非递归O（1）