二分查找

Posted limaodeng

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了二分查找相关的知识,希望对你有一定的参考价值。

一、前提

二分查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列。

二、算法步骤

  1. 置查找区间初值,left为0,right为表长-1。

  2. 当left小于等于right时,循环执行以下操作:

    1)middle取值为low和high的中间值;

    2)将给定值target与中间位置记录的关键字进行比较,

    如果target比中间的位置记录的关键字小,则right = middle - 1;

    如果target比中间的位置记录的关键字大,则left = middle + 1;

    若相等则查找成功,返回中间位置middle。

三、循环版-二分查找

    /**
     * 循环版-二分查找
     * @param array 有序数组
     * @param left  左下标
     * @param right 右下标
     * @param target 要查找的元素
     * @return
     */
    public static int binarySearch(int[] array,int target){
        int left = 0;
        int right = array.length - 1;
        while (left <= right){
            int middle = left + ((right - left) >> 1);
            if(array[middle] > target){ //大于
                right = middle - 1;
            }else if(array[middle] < target){ //小于
                left = middle + 1;
            }else { //等于(此情况较少出现,所以放在后面)
                return middle;
            }
        }
        return -1; //找不到
    }

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

四、递归版-二分查找

    /**
     * 递归版-二分查找
     * @param array 有序数组
     *  param left  左下标
     *  param right 右下标
     * @param target 要查找的元素
     * @return
     */
    public static int recursiveBSearch(int[] array,int left,int right,int target){
        if(left > right){
            return -1;
        }
        //计算中间角标
        int middle = left + ((right - left) >> 1);

        if(array[middle] > target){//大于
            return recursiveBSearch(array,left,middle - 1,target);
        }else if(array[middle] < target){//小于
            return recursiveBSearch(array,middle + 1,right,target);
        }else { //等于
            return middle;
        }

    }
    
    public static void main(String[] args){
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        int result = recursiveBSearch(arr,0,arr.length - 1,6);
        System.out.println(result);
    }

四、时间复杂度

二分查找的时间复杂度无非就是while循环的次数

总共有n个元素,

渐渐跟下去就是n,n/2,n/4,....n/2^k,其中k就是循环的次数

由于你n/2^k取整后>=1

即令n/2^k=1

可得k=log2n,(是以2为底,n的对数)

所以时间复杂度为 O(logn)

六、注意

1.中间值得计算有两种方式

方式一:int middle = (left + right) >> 1;

方式二:int middle = left + ((right - left) >> 1);

方式一存在溢出的风险,当left比right大时,有可能会导致mid的值错误。

方式二则可以保证生成的middle一定大于left,小于right。

2.循环执行的条件是 left <= right,而不是left< right,

因为left = right时,查找区间还有最后一个结点,还要进一步比较。

七、演进版

1、查找第一个等于给定值的元素

    /**
     * 查找第一个等于给定值的元素
     * @param array 有序数组
     * @param target 要查找的元素
     * @return
     */
    public static int firstEqualBSearch(int[] array,int target){
        int left = 0;
        int right = array.length - 1;
        while (left <= right){

            int middle = left + ((right - left) >> 1);

            if(array[middle] > target){ //大于
                right = middle - 1;
            }else if(array[middle] < target){ //小于
                left = middle + 1;
            }else { //等于
                //如果当前为第一个元素或者
                //当前元素的前一个元素不等target,则返回当前角标
                //否则继续查找
                if(middle == 0 || array[middle - 1] != target ){
                    return middle;
                }else {
                    right = middle - 1;
                }
            }
        }
        return -1; //找不到
    }

2、查找第一个大于给定值的元素

    /**
     * 查找第一个大于给定值的元素
     * @param array 有序数组
     * @param target 要查找的元素
     * @return
     */
    public static int firstGreaterBSearch(int[] array,int target){
        int left = 0;
        int right = array.length - 1;
        while (left <= right){

            int middle = left + ((right - left) >> 1);

            if(array[middle] > target){ //大于
                //如果当前是第一个元素,
                //或者当前元素的前一个元素小于等于给定值,则返回
                //否则继续查找
                if (middle == 0 || array[middle-1] <= target){
                    return middle;
                }else {
                    right =  middle - 1;
                }
            }else {
                left = middle + 1;
            }
        }
        return -1; //找不到
    }

3、查找最后一个小于给定值的元素

    /**
     * 查找最后一个小于给定值的元素
     * @param array 有序数组
     * @param target 要查找的元素
     * @return
     */
    public static int firstLessBSearch(int[] array,int target){
        int left = 0;
        int right = array.length - 1;
        while (left <= right){

            int middle = left + ((right - left) >> 1);

            if(array[middle] < target){ //小于
                //如果当前是第一个元素,
                //或者当前元素的后一个元素大于等于给定值,则返回
                //否则继续查找
                if (middle == 0 || array[middle+1] >= target){
                    return middle;
                }else {
                    left =  middle + 1;
                }
            }else {
                right = middle - 1;
            }
        }
        return -1; //找不到
    }

以上是关于二分查找的主要内容,如果未能解决你的问题,请参考以下文章

java 二分查找法

代码题(12)— 二分查找

二分查找代码

PHP实现二分查找算法(代码详解)

「算法笔记」一文摸秃二分查找

C语言二分查找