二分查找算法

package twoG;
/**
 * 二分算法  :  优点-->比较次数少，查找速度快，平均性能好。  缺点-->要求待查表为有序表，且插入删除困难。
 *                 适用于不经常变动而查找频繁的有序列表
 * 
 * 二分查找的基本思想是将n个元素分成大致相等的俩个部分，去a[n/2]与x作比较，如果x=a[n/2]，算法终止，
 * 如果x<a[n/2]，则要在x的左半部分搜索x，如果x>a[n/2],则要在x的右半部分搜索x
 * @author DELL
 *
 */
public class BinarySearch {

    private int rCount = 0;
    private int lCount = 0;
    /**
     * 获取递归的次数
     */
    public int getrCount(){
        return rCount;
    }
    /**
     * 获取循环次数
     * 
     */
    public int getlCount(){
        return lCount;
    }
    /**
     * 执行递归二分算法，返回第一次出现该值的位置
     * sortedDate 已经排序的数组
     * start 开始位置
     * end  结束位置
     * findValue  需要找的值
     * return   在数组中的位置，从0开始，找不到返回-1
     * 
     * 
     */
    public int searchRecursive(int[] sortedData,int start,int end,int findValue)  
    {  
        rCount++;    //递归次数
        if(start<=end)  
        {  
            //中间位置  
            int middle=(start+end)>>1;    //相当于(start+end)/2  
            //中值  
            int middleValue=sortedData[middle];  
              
            if(findValue==middleValue)  
            {  
                //等于中值直接返回  
                return middle;  
            }  
            else if(findValue<middleValue)  
            {  
                //小于中值时在中值前面找  
                return searchRecursive(sortedData,start,middle-1,findValue);  
            }  
            else  
            {  
                //大于中值在中值后面找  
                return searchRecursive(sortedData,middle+1,end,findValue);  
            }  
        }  
        else  
        {  
            //找不到  
            return -1;  
        }  
    }  
      
    /** 
     * 循环二分查找，返回第一次出现该值的位置 
     * @param sortedData    已排序的数组 
     * @param findValue     需要找的值 
     * @return              值在数组中的位置，从0开始。找不到返回-1 
     */  
    public int searchLoop(int[] sortedData,int findValue)  
    {  
        int start=0;  
        int end=sortedData.length-1;  
          
        while(start<=end)  
        {  
            lCount++;   //循环次数
            //中间位置  
            int middle=(start+end)>>1;    //相当于(start+end)/2  
            //中值  
            int middleValue=sortedData[middle];  
              
            if(findValue==middleValue)  
            {  
                //等于中值直接返回  
                return middle;  
            }  
            else if(findValue<middleValue)  
            {  
                //小于中值时在中值前面找  
                end=middle-1;  
            }  
            else  
            {  
                //大于中值在中值后面找  
                start=middle+1;  
            }  
        }  
        //找不到  
        return -1;  
    }  
     
}

package twoG;

public class BinarySearchTest {
    public void testSearch()  
    {  
        BinarySearch bs=new BinarySearch();  
          
        int[] sortedData={1,2,3,4,5,6,6,7,8,8,9,10};  
        int findValue=9;  
        int length=sortedData.length;  
        /**
         * 递归二分算法  
         */
        int pos=bs.searchRecursive(sortedData, 0, length-1, findValue);  
        System.out.println("Recursice:"+findValue+" found in pos "+pos+";count:"+bs.getrCount());  
        /**
         * 循环二分查找
         */
        int pos2=bs.searchLoop(sortedData, findValue);   
        System.out.println("Loop:"+findValue+" found in pos "+pos+";count:"+bs.getlCount());  
    }  
    public static void main(String[] args){
        BinarySearchTest t = new BinarySearchTest();
        t.testSearch();
    }
}