二分查找算法(Java版)

二分查找算法是非常经典且基本的算法。

1.二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

2.算法要求：必须采用顺序存储结构; 必须按关键字大小有序排列。

3.基本思想:将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。如 果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。如果x>a[n/2]，则我们只要在数组a的右 半部继续搜索x。

4.复杂度:O(logn)

5.注意问题：

int mid =(low + high) / 2;
在一般情况下, 这个语句是不会出错的, 但是, 当low+high的值超过了最大的正int值 (231 - 1) 的时候, mid会变成负值,  这个时候, 会抛出ArrayIndexOutOfBoundsException 异常。所以当一个数组包含超过2的30次方 个元素的时候, 就很可能会带来问题;当然, 在一般的应用里面, 很少数组会包含那么多元素, 但是现在这样的情况已经越来越多了, 比如Google的海量运算……那如何解决这个问题？

可以改为： int mid = low + ((high - low) / 2); 或  int mid = (low + high) >>> 1;

完整代码如下：

class BinarySearch{
	//非递归
	public static int binarySearch(int[] a,int fromIndex,int toIndex,int value){
		int low=fromIndex;
		int high=toIndex-1;
		while(low<=high){
			int mid=(low+high)>>>1;
			int midVal=a[mid];
			if(midVal<value)
				low=mid+1;
			else if(midVal>value)
				high=mid-1;
			else return mid;
		}
		return -1;
	}
	//递归
	public static int binarySearch1(int[] a,int fromIndex,int toIndex,int value){
		if(fromIndex>toIndex)
			return -1;
		int mid=(fromIndex+toIndex)>>>1;
		if(a[mid]<value){
			return binarySearch1(a,mid+1,toIndex,value);
		}else if(a[mid]>value){
			return binarySearch1(a,fromIndex,mid-1,value);
		}else{
			return mid;
		}
	}
	public static void main(String[] args){
		int[] a={2,3,5,7,9,13,18};
		System.out.println(binarySearch(a,0,7,13));
		System.out.println(binarySearch1(a,0,7,18));
	}
}

//二分查找V0.1实现版  
//copyright@2011 July  
//随时欢迎读者找bug，email：zhoulei0907@yahoo.cn。  
  
//首先要把握下面几个要点：  
//right=n-1 => while(left <= right) => right=middle-1;  
//right=n   => while(left <  right) => right=middle;  
//middle的计算不能写在while循环外，否则无法得到更新。  
  
int binary_search(int array[],int n,int value)  
{  
    int left=0;  
    int right=n-1;  
    //如果这里是int right = n 的话，那么下面有两处地方需要修改，以保证一一对应：  
    //1、下面循环的条件则是while(left < right)  
    //2、循环内当array[middle]>value 的时候，right = mid  
  
    while (left<=right)          //循环条件，适时而变  
    {  
        int middle=left + ((right-left)>>1);  //防止溢出，移位也更高效。同时，每次循环都需要更新。  
  
        if (array[middle]>value)  
        {  
            right =middle-1;   //right赋值，适时而变  
        }   
        else if(array[middle]<value)  
        {  
            left=middle+1;  
        }  
        else  
            return middle;    
        //可能会有读者认为刚开始时就要判断相等，但毕竟数组中不相等的情况更多  
        //如果每次循环都判断一下是否相等，将耗费时间  
    }  
    return -1;  
}