Java二进制搜索计数比较数

我用java编写了以下二进制搜索代码：

import java.util.Arrays;

class BinarySearch  {
    public static int binarySearch(double[] arr, double x, int high, int low)   {
        int mid=(high+low)/2;
        if(high==low || low==mid || high==mid)  {
            return -1;
        }
        if(arr[mid]<x)  {
            return binarySearch(arr, x, high, mid);
        }
        else if(arr[mid]>x) {
            return binarySearch(arr, x, mid, low);
        }
        else if(arr[mid]==x)    {
            return mid;
        }
        return -1;
    }

    public static void main(String args[])  {
        int n=1000;
        double array[] = new double[n];
        for (int i=0; i<100; i++)   {
            for (int k = 0; k < n; k++) {
                double r = Math.random();
                r = r * 100;
                r = Math.round(r);
                r = r / 100;
                array[k] = r;
            }
            Arrays.sort(array);
            double search = Math.random();
            search = search * 100;
            search = Math.round(search);
            search = search / 100;
            int result=binarySearch(array, search, n, 0);
            if (result == -1)
                System.out.println(search +" befindet sich nicht im Array.");
            else
                System.out.println(search+" befindet sich im Array an der Stelle "+(result)+".");
    }
}

导入java.util.array；
类二进制搜索{
公共静态整数二进制搜索（双[]arr，双x，整数高，整数低）{
int mid=（高+低）/2；
如果（高==低| |低==中| |高==中）{
返回-1；
}
中频（arr[mid]x）{
返回二进制搜索（arr、x、mid、low）；
}
否则如果（arr[mid]==x）{
中途返回；
}
返回-1；
}
公共静态void main（字符串参数[]）{
int n=1000；
双数组[]=新的双数组[n]；
对于（int i=0；i在代码顶部声明一个
int
，并在每个返回语句之前递增它（因为这是比较的最后一步）

您可以通过递归方法的调用链传递比较次数，如下所示：

public static int binarySearch(double[] arr, double x, int high, int low, int cmp) {
    ...
    if(arr[mid]<x)  {
        // We made one additional comparison
        return binarySearch(arr, x, high, mid, cmp+1);
    } else if(arr[mid]>x) {
        // We made two additional comparisons
        return binarySearch(arr, x, mid, low, cmp+2);
    } else {
        // We made two additional comparisons.
        // We are about to return the result, so print the final number of comparisons:
        System.out.println("Performed "+(cmp+2)+" comparisons.");
        return mid;
    }
}

公共静态int-binarySearch（双[]arr，双x，int-high，int-low，int-cmp）{
...
中频（arr[mid]x）{
//我们又做了两次比较
返回二进制搜索（arr、x、mid、low、cmp+2）；
}否则{
//我们又做了两次比较。
//我们即将返回结果，因此请打印比较的最终数量：
System.out.println（“执行”+（cmp+2）+“比较”）；
中途返回；
}
}

在从
main
调用的
cmp
参数中传递零，这样做可以使事情变得简单

private static int comparisions = 0;

public static int binarySearch(double[] arr, double x, int high, int low) {
    int mid = (high + low) / 2;
    if (high == low || low == mid || high == mid) {
        comparisions++;
        return -1;
    }
    if (arr[mid] < x) {
        comparisions++;
        return binarySearch(arr, x, high, mid);
    } else if (arr[mid] > x) {
        comparisions++;
        return binarySearch(arr, x, mid, low);
    } else if (arr[mid] == x) {
        comparisions++;
        return mid;
    }
    return -1;
}

public static void main(String args[]) {
    int n = 1000;
    double array[] = new double[n];
    for (int i = 0; i < 100; i++) {
        for (int k = 0; k < n; k++) {
            double r = Math.random();
            r = r * 100;
            r = Math.round(r);
            r = r / 100;
            array[k] = r;
        }
        Arrays.sort(array);
        double search = Math.random();
        search = search * 100;
        search = Math.round(search);
        search = search / 100;
        int result = binarySearch(array, search, n, 0);
        System.out.println("Number of comparisions " +  comparisions);
        if (result == -1)
            System.out.println(search + " befindet sich nicht im Array.");
        else
            System.out.println(search + " befindet sich im Array an der Stelle " + (result) + ".");
    }

}

私有静态int比较=0；
公共静态整数二进制搜索（双[]arr，双x，整数高，整数低）{
int mid=（高+低）/2；
如果（高==低| |低==中| |高==中）{
比较++；
返回-1；
}
中频（arr[mid]x）{
比较++；
返回二进制搜索（arr、x、mid、low）；
}否则如果（arr[mid]==x）{
比较++；
中途返回；
}
返回-1；
}
公共静态void main（字符串参数[]）{
int n=1000；
双数组[]=新的双数组[n]；
对于（int i=0；i<100；i++）{
对于（int k=0；k
在
binarysearch（）之外声明一个变量。

num\u of_calls
将包含调用递归函数的次数

private static int comparisions = 0;

public static int binarySearch(double[] arr, double x, int high, int low) {
    int mid = (high + low) / 2;
    if (high == low || low == mid || high == mid) {
        comparisions++;
        return -1;
    }
    if (arr[mid] < x) {
        comparisions++;
        return binarySearch(arr, x, high, mid);
    } else if (arr[mid] > x) {
        comparisions++;
        return binarySearch(arr, x, mid, low);
    } else if (arr[mid] == x) {
        comparisions++;
        return mid;
    }
    return -1;
}

public static void main(String args[]) {
    int n = 1000;
    double array[] = new double[n];
    for (int i = 0; i < 100; i++) {
        for (int k = 0; k < n; k++) {
            double r = Math.random();
            r = r * 100;
            r = Math.round(r);
            r = r / 100;
            array[k] = r;
        }
        Arrays.sort(array);
        double search = Math.random();
        search = search * 100;
        search = Math.round(search);
        search = search / 100;
        int result = binarySearch(array, search, n, 0);
        System.out.println("Number of comparisions " +  comparisions);
        if (result == -1)
            System.out.println(search + " befindet sich nicht im Array.");
        else
            System.out.println(search + " befindet sich im Array an der Stelle " + (result) + ".");
    }

}

import java.util.Arrays;
   class BinarySearch  {
      int num_of_calls = 0;
      public static int binarySearch(double[] arr, double x, int high, int low)   {
         num_of_calls++;
        ...
        }