二分查找

1、基本思想：每次将序列中间值与待查找的元素值作比较，每次将搜索区间缩小一半，直到缩小到一个对象为止。

2、二分查找要求：必须顺序存储、 必须按关键码大小有序排序

3、实现步骤：

• 对数组进行排序
• 找到序列的中间位置mid = （low+high）/2，low=0,high=array.length-1,比较array[mid]与待查找元素值x的大小
• 如果array[mid]==x，那么返回元素在数组中的位置，如果array[mid]<x,则low = mid+1, 否则high = mid-1
• 继续同样的操作，直到low>high，还没找到就返回-1

4、代码实现

  
  

  
  

   
   

    
    

     
     1
    
    
    
    

     
     2
     
     
    
    
    
    

     
     3
    
    
    
    

     
     4
    
    
    
    

     
     5
    
    
    
    

     
     6
     
     
    
    
    
    

     
     7
    
    
    
    

     
     8
    
    
    
    

     
     9
    
    
    
    

     
     10
    
    
    
    

     
     11
    
    
    
    

     
     12
    
    
    
    

     
     13
    
    
    
    

     
     14
    
    
    
    

     
     15
    
    
    
    

     
     16
    
    
   
   
   
   

  
  
  
  

   
   

    
    

     
     

    
    
    
    

     
     

    
    
    
    

     
     

      
      
 
       //折半查找算法,需要先进行排序,循环方式 
      
     
     
     
     

      
      
 
       public  
       int  
       binarySearch( 
       int[]  
       array,  
       int  
       x){ 
      
     
     
     
     

      
      

             
       Arrays. 
       sort( 
       array); 
      
     
     
     
     

      
      

             
       int  
       low  
       =  
       0,  
       high  
       =  
       array. 
       length 
       -1; 
      
     
     
     
     

      
      

             
       int  
       mid  
       =  
       0; 
      
     
     
     
     

      
      

             
       while( 
       low 
       <= 
       high){ 
      
     
     
     
     

      
      

                 
       mid  
       = ( 
       low 
       + 
       high)/ 
       2; 
      
     
     
     
     

      
      

                 
       if( 
       array[ 
       mid] 
       == 
       x)  
      
     
     
     
     

      
      

                   
       return  
       mid; 
      
     
     
     
     

      
      

                 
       else  
       if( 
       array[ 
       mid] 
       > 
       x) 
      
     
     
     
     

      
      

                   
       high  
       =  
       mid 
       -1; 
      
     
     
     
     

      
      

                 
       else 
      
     
     
     
     

      
      

                   
       low  
       =  
       mid 
       +1; 
      
     
     
     
     

      
      

            } 
      
     
     
     
     

      
      

             
       return  
       -1; 
      
     
     
     
     

      
      

        } 
      
     
     
    
    
    
    

    
    

     
     

    
    
   
   
  
  
  
  

   
   

   
   

  
  

  
  

  
  

   
   

  
  
  
  

   
   

    
    

     
     

    
    
    
    

     
     

    
    
    
    

     
     

      
      
 
       //递归方法,空间复杂度O(logn) 
      
     
     
     
     

      
      
 
       public  
       int  
       binarySearch( 
       int[]  
       array,  
       int  
       x,  
       int  
       low,  
       int  
       high){ 
      
     
     
     
     

      
      

             
       int  
       mid  
       =  
       0; 
      
     
     
     
     

      
      

             
       if( 
       low 
       <= 
       high){ 
      
     
     
     
     

      
      

                 
       mid  
       = ( 
       low 
       + 
       high)/ 
       2; 
      
     
     
     
     

      
      

                 
       if( 
       array[ 
       mid] 
       == 
       x)  
      
     
     
     
     

      
      

                    
       return  
       mid; 
      
     
     
     
     

      
      

                 
       else  
       if( 
       array[ 
       mid] 
       > 
       x) 
      
     
     
     
     

      
      

                    
       return  
       binarySearch( 
       array, 
       x, 
       low, 
       mid 
       -1); 
      
     
     
     
     

      
      

                 
       else 
      
     
     
     
     

      
      

                    
       return  
       binarySearch( 
       array, 
       x, 
       mid 
       +1, 
       high); 
      
     
     
     
     

      
      

            } 
      
     
     
     
     

      
      

             
       return  
       -1; 
      
     
     
     
     

      
      

        } 
      
     
     
    
    
    
    

    
    

     
     

    
    
   
   
  
  
  
  

   
   

   
   

  
  

5、时间复杂度：O(logn)