折半查找

/**
 * 折半查找
 * @author Raymond
 *
 */
public class BinarySearch {

    /*public static void main(String[] args) {
            int[] arr = {10,11,12,18,19,20};
            int target = 119;
            System.out.println("Target Position : " + binary(arr, target));
    }*/
    
    public static int binary(int[] arr, int target) {
        int low = 0;
        int high = arr.length-1;
        //int mid = (low + high)/2;
        while (arr[(low + high)/2] != target) { // 折半比较
            int mid = (low + high)/2;
            System.out.println("mid: "+mid);
            if (target > arr[mid]) 
                low = mid + 1;
            if (target < arr[mid])
                high = mid - 1;    
            if (low > high)
                break;
        }
        if (target == arr[(low + high)/2])
            return (low + high)/2;
        System.out.println("Not Found Target");
        return -1;
    }

}

 Others

public static int binarySearch(Integer[] srcArray, int des) {
    //定义初始最小、最大索引
    int start = 0;
    int end = srcArray.length - 1;
    //确保不会出现重复查找，越界
    while (start <= end) {
        //计算出中间索引值
        int middle = (end + start)>>>1 ;//防止溢出
        if (des == srcArray[middle]) {
            return middle;
        //判断下限
        } else if (des < srcArray[middle]) {
            end = middle - 1;
        //判断上限
        } else {
            start = middle + 1;
        }
    }
    //若没有，则返回-1
    return -1;
}

算法复杂度分析

二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.

时间复杂度即是while循环的次数。

总共有n个元素，

渐渐跟下去就是n,n/2,n/4,....n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数

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

即令n/2^k=1

可得k=log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O(h)=O(log2n)