java 二分查找法

Posted 2023-04-27

public class BinarySearch
public static void main(String[] args)
int[] a = 2,4,6,9;
int key = 2;
BinarySearch(a, key);
System.out.println("The key is in " + BinarySearch(a,key));

public static int BinarySearch(int[] list, int key)
int low = 0;
int high = list.length - 1;

while (high >= low)
int mid = (low + high) / 2;
if(key < list[mid])
high = mid - 1;
else if (key == mid)
return mid;
else
low = mid + 1;


return - low - 1;



为什么print出的结果是The key is in -2， 但实际上key（2）的下标应该是0，不是-2?
求助各位大虾~~

参考技术A public class BinarySearch 
public static void main(String[] args) 
int[] a =  2, 4, 6, 9 ;
int key = 2;
BinarySearchM(a, key);
System.out.println("The key is in " + BinarySearchM(a, key));


public static int BinarySearchM(int[] list, int key) 
int low = 0;
int high = list.length - 1;

while (high >= low) 
int mid = (low + high) / 2;
System.out.println(mid);
if (key < list[mid])//mid 改为 list[mid]
high = mid - 1;
else if (key == list[mid])
return mid;
else
low = mid + 1;

return -low - 1;

本回答被提问者和网友采纳 参考技术B package test;
public class Search
public Search()


/**
* @param data 从小到大排好序的数组
* @param goal 要查找的数
* @param left
* @param right
* @return 目标数的数组下标，没有找到为-1 ;
*/
public static int find(int[] data,int goal,int left,int right)
int mid = (left+right)/2 ;
if(left>right)
return -1 ;

if(goal==data[mid])
return mid ;

else if(goal<data[mid])
//注意right = mid -1 ;
return find(data,goal,left,mid-1);

else if(goal>data[mid])
return find(data,goal,mid+1,right);

return -1 ;


public static void main(String[] args)
int[] data = new int[] 1,2,4,6,7;
int result =find(data,6,0,data.length-1) ;
System.out.println(result);


希望能解决您的问题。

二分查找算法（递归与非递归两种方式）

首先说说二分查找法。

二分查找法是对一组有序的数字中进行查找，传递相应的数据，进行比较查找到与原数据相同的数据，查找到了返回1，失败返回对应的数组下标。

采用非递归方式完成二分查找法。java代码如下所示。

[java] view plain copy

 print?

1.     /* 
2.      * 非递归二分查找算法 
3.      * 参数:整型数组,需要比较的数. 
4.      */  
5.     public static int binarySearch(Integer[]srcArray,int des){  
6.         //第一个位置.  
7.         int low=0;  
8.         //最高位置.数组长度-1,因为下标是从0开始的.  
9.         int high=srcArray.length-1;  
10.         //当low"指针"和high不重复的时候.  
11.         while(low<=high){  
12.             //中间位置计算,low+ 最高位置减去最低位置,右移一位,相当于除2.也可以用(high+low)/2  
13.             int middle=low+((high-low)>>1);  
14.         //与最中间的数字进行判断,是否相等,相等的话就返回对应的数组下标.  
15.         if(des==srcArray[middle]){  
16.             return middle;  
17.         //如果小于的话则移动最高层的"指针"  
18.         }else if(des<srcArray[middle]){  
19.             high=middle-1;  
20.         //移动最低的"指针"   
21.         }else{  
22.             low=middle+1;  
23.             }  
24.         }  
25.         return-1;  
26.         }  
27.       
28. }  

采用递归方式完成二分查找算法。代码如下所示。

[java] view plain copy

 print?

1. /** 
2.  * 递归方法实现二分查找法. 
3.  * @param Array数组 
4.  * @param low 数组第一位置 
5.  * @param high 最高 
6.  * @param key 要查找的值. 
7.  * @return 返回值. 
8.  */  
9. int BinSearch(int Array[],int low,int high,int key)  
10. {  
11.     if (low<=high)  
12.     {  
13.         int mid = (low+high)/2;  
14.         if(key == Array[mid])  
15.             return mid;  
16.         else if(key<Array[mid])  
17.             //移动low和high  
18.             return BinSearch(Array,low,mid-1,key);  
19.         else if(key>Array[mid])  
20.             return BinSearch(Array,mid+1,high,key);  
21.     }  
22.     else  
23.         return -1;  
24. }  

递归思想会被经常用到，更加突出了编程解决问题的高效。 print?

1.     /* 
2.      * 非递归二分查找算法 
3.      * 参数:整型数组,需要比较的数. 
4.      */ 
5.     public static int binarySearch(Integer[]srcArray,int des){ 
6.         //第一个位置. 
7.         int low=0; 
8.         //最高位置.数组长度-1,因为下标是从0开始的. 
9.         int high=srcArray.length-1; 
10.         //当low"指针"和high不重复的时候. 
11.         while(low<=high){ 
12.             //中间位置计算,low+ 最高位置减去最低位置,右移一位,相当于除2.也可以用(high+low)/2 
13.             int middle=low+((high-low)>>1); 
14.         //与最中间的数字进行判断,是否相等,相等的话就返回对应的数组下标. 
15.         if(des==srcArray[middle]){ 
16.             return middle; 
17.         //如果小于的话则移动最高层的"指针" 
18.         }else if(des<srcArray[middle]){ 
19.             high=middle-1; 
20.         //移动最低的"指针"  
21.         }else{ 
22.             low=middle+1; 
23.             } 
24.         } 
25.         return-1; 
26.         } 
27.      
28. } 

采用递归方式完成二分查找算法。代码如下所示。

[java] view plain copy

 print?

1. /** 
2. * 递归方法实现二分查找法. 
3. * @param Array数组 
4. * @param low 数组第一位置 
5. * @param high 最高 
6. * @param key 要查找的值. 
7. * @return 返回值. 
8. */ 
9. int BinSearch(int Array[],int low,int high,int key) 
10. { 
11.     if (low<=high) 
12.     { 
13.         int mid = (low+high)/2; 
14.         if(key == Array[mid]) 
15.             return mid; 
16.         else if(key<Array[mid]) 
17.             //移动low和high 
18.             return BinSearch(Array,low,mid-1,key); 
19.         else if(key>Array[mid]) 
20.             return BinSearch(Array,mid+1,high,key); 
21.     } 
22.     else 
23.         return -1; 
24. } 

递归思想会被经常用到，更加突出了编程解决问题的高效。