使用或不使用递归的二分查找

不使用递归的二分查找

public class Main {

    public static void main(String[] args) {
        int[] array = {9, 5, 2, 6, 1, 3, 8, 4, 10, 7};
      int j;

     for (int i=1;i<array.length;i++){
         int number=array[i];
         j=i;
         while (j>0&&number<array[j-1]){
             array[j]=array[j-1];
             j--;
         }
         array[j]=number;
     }

      findTwoPoint(array,5);

    }

    public static int findTwoPoint(int[] array,int key) {
        int start=0;
        int last=array.length-1;
        int number=(last-start)/2+start;
        while (start<=last){
            if (key==array[number]){
                System.out.println(number);
                return key;
            }else if (key<array[number]){
                number=last-1;
            }else if (number>array[number]){
                number=start+1;
            }
        }
        return -1;
    
}

}

控制台输出：4   


使用递归的二分查找

　递归，就是在运行的过程中调用自己。

　　递归必须要有三个要素：

　　①、边界条件

　　②、递归前进段

　　③、递归返回段

　　当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

public class Main {

    public static void main(String[] args) {
        int[] array = {9, 5, 2, 6, 1, 3, 8, 4, 10, 7};
      int j;

     for (int i=1;i<array.length;i++){
         int number=array[i];
         j=i;
         while (j>0&&number<array[j-1]){
             array[j]=array[j-1];
             j--;
         }
         array[j]=number;
     }

      findTwoPoint(array,5,10,0);

    }

    public static int findTwoPoint(int[] array,int key,int high,int low) {
        int number=(high-low)/2+low;

            if (key==array[number]){
                System.out.println(number);
                return key;
            }else if (low>high){
                return -1;
            }else {
                if (number>array[number]){
                  return findTwoPoint(array,key,high,low+1);
                }
                if (number<array[number]){
                    return findTwoPoint(array,key,high-1,low);
                }
            }

        return -1;

}

控制台输出：4   

递归的二分查找和非递归的二分查找效率都为O(logN)，递归的二分查找更加简洁，便于理解，但是速度会比非递归的慢。