折半查找的递归与非递归算法

Java代码

1. public class biSearch {
3. /**
4. * @param args
5. * 作者：undoner
6. /*
7. 折半查找--当查找表是有序表时，可采用折半查找;
8. 基本思想：在有序表中，取中间元素作为比较对象，若给定值K与中间记录关键字相等，则查找成功；
9. 若给定值K小于中间记录的关键字，则在表的左半区继续查找；
10. 若给定值K大于中间记录的关键字，则在表的右半区继续查找，不断重复，直到查找成功/失败。
11. */
13. //折半查找非递归算法
14. //查询成功返回该对象的下标序号，失败时返回-1。
15. int BiSearch(int r[],int n,int k)
16. {
17. int low=0;
18. int high=n-1;
19. while(low<=high)
20. {
21. int mid=(low+high)/2;
22. if(r[mid]==k)
23. return mid;
24. else
25. if(r[mid]<k)
26. low=mid+1;
27. else
28. high=mid-1;
29. }
30. return -1;
31. }
34. //折半查找递归算法
35. //查询成功返回该对象的下标序号，失败时返回-1。
36. int BiSearch2(int r[],int low,int high,int k)
37. {
38. if(low<0) low=0;
39. if(high>=r.length) high=r.length-1; //简单的参数验证
40. if(low>high)
41. return -1;
42. else
43. {
44. int mid=(low+high)/2;
45. if(r[mid]==k)
46. return mid;
47. else
48. if(r[mid]<k)
49. return BiSearch2(r,mid+1,high,k);
50. else
51. return BiSearch2(r,low,mid-1,k);
53. }
54. }
56. public static void main(String[] args) {
57. biSearch bs=new biSearch();
58. int r[]={1,2,3,4,5};
59. System.out.println(bs.BiSearch(r,5,5));
60. System.out.println(bs.BiSearch2(r,0,4,5));
61. System.out.println(bs.BiSearch2(r,0,5,5));
62. }
64. }

public class biSearch { 
 
    /**
     * @param args
     * 作者：undoner 
    /*
    折半查找--当查找表是有序表时，可采用折半查找;
    基本思想：在有序表中，取中间元素作为比较对象，若给定值K与中间记录关键字相等，则查找成功；
    若给定值K小于中间记录的关键字，则在表的左半区继续查找；
    若给定值K大于中间记录的关键字，则在表的右半区继续查找，不断重复，直到查找成功/失败。
    */ 
 
    //折半查找非递归算法 
    //查询成功返回该对象的下标序号，失败时返回-1。 
    int BiSearch(int r[],int n,int k) 
    { 
        int low=0; 
        int high=n-1; 
        while(low<=high) 
        { 
            int mid=(low+high)/2; 
            if(r[mid]==k) 
                return mid; 
            else 
                if(r[mid]<k) 
                    low=mid+1; 
                else 
                    high=mid-1; 
        } 
        return -1; 
    } 
 
 
    //折半查找递归算法 
    //查询成功返回该对象的下标序号，失败时返回-1。 
    int BiSearch2(int r[],int low,int high,int k) 
    { 
        if(low<0) low=0;
        if(high>=r.length) high=r.length-1; //简单的参数验证
        if(low>high) 
            return -1; 
        else 
        { 
            int mid=(low+high)/2; 
            if(r[mid]==k) 
                return mid; 
            else 
                if(r[mid]<k) 
                    return BiSearch2(r,mid+1,high,k); 
                else 
                    return BiSearch2(r,low,mid-1,k); 
 
        } 
    } 
     
    public static void main(String[] args) { 
        biSearch bs=new biSearch(); 
        int r[]={1,2,3,4,5}; 
        System.out.println(bs.BiSearch(r,5,5)); 
        System.out.println(bs.BiSearch2(r,0,4,5)); 
        System.out.println(bs.BiSearch2(r,0,5,5)); 
    } 
 
}  
  

运行:
C:\java>java biSearch
4
4
4 

转载于:https://blog.51cto.com/daheyuan/1140090