递归和非递归实现二分查找

1. public class Find  
2. {  
3.     //使用非递归方法实现  
4.     public static int binFind1(int[] orderedArr, int numFind)  
5.     {  
6.         int hi = 0, mid=0,lo = 0;  
7.         hi = orderedArr.length - 1;  
8.         lo = 0;  

    

1.              
2.       while(lo<=hi)  
3.         {  
4.             mid = (hi + lo) / 2;  
5.             if (numFind == orderedArr[mid])  
6.             {  
7.                 //直接返回结束当前运行方法  
8.                 return (hi + lo) / 2;  
9.                      
10.             }  
11.             if (numFind > orderedArr[mid])  
12.             {  
13.                 //改变下角标  
14.                 //【注】理解为什么+1，因为这样的二分之后改变了首部  
15.                 lo = mid+1;  
16.             }  
17.             if(numFind<orderedArr[mid])  
18.             {  
19.                 //改变上角标  
20.                 //【注】理解为什么-1，因为这样的二分之后改变了尾部  
21.                 hi=mid-1;  
22.             }  
23.      
24.         }  
25.         //未找到  
26.          return -1;  
27.     }  
28.      
29.     //使用递归方法实现：  
30.     public static int binFind2(int arr[],int lo/*七点*/,int hi/*终点*/,int num/*要查找的数字*/)  
31.     {  
32.         if(lo<=hi)// 注意这里的条件是<=  
33.         {  
34.             int mid = (lo+hi)/2;  
35.                  
36.             if(num<arr[mid])  
37.             {  
38.                 return binFind2(arr,lo,mid - 1,num);  
39.             }  
40.             if(num>arr[mid])  
41.             {  
42.                 return binFind2(arr,mid +1,hi,num);  
43.             }  
44.             if(arr[mid]==num)  
45.             {  
46.                 return mid;  
47.             }  
48.                  
49.         }  
50.         return -1;//未找到  
51.     }  
52.     public static void main(String[] args)  
53.     {  
54.         // TODO Auto-generated method stub

        //测试用例  

1.         int[] orderedArr = {1,2,3,4,6,7,8};  
2.         System.out.println(binFind2(orderedArr,0,orderedArr.length,5));  
3.              
4.     }  
5.      
6. }