Question

如何在java中仅使用1个参数在int数组中实现递归二进制搜索？它试过，但我的代码不起作用。我实现了一个类，其实例是具有数组和count变量的对象，以检测数组中它们的元素数量。任何想法如何只使用1个参数实现递归二进制搜索？

public class LinearSortedArray {
    int count;
    int[] a;

    public LinearSortedArray() {
        count = 0;
    }

    public LinearSortedArray(int size) {
        count = 0;
        a = new int[size];
    }

    public static int[] copyingMethod(int startPoint, int endPoint,
            LinearSortedArray arrayObj) {
        int[] copyingArray = new int[endPoint - startPoint];
        int j = startPoint;
        for (int i = 0; i < copyingArray.length; i++) {
            copyingArray[i] = arrayObj.a[j];
            j++;
        }
        return copyingArray;
    }

    public int binarySearchRec(int x) {
        if (count == 0) {
            return -1;
        }
        int pivot = count / 2;
        LinearSortedArray newArrayObj;
        if (x > a[pivot]) {
            newArrayObj = new LinearSortedArray(count - pivot);
            newArrayObj.count = newArrayObj.a.length;
            newArrayObj.a = copyingMethod(pivot, count, this);

            for (int i = 0; i < newArrayObj.a.length; i++) {
                System.out.print(newArrayObj.a[i]);
                System.out.print(" ");
            }
            System.out.println();
            return pivot + newArrayObj.binarySearchRec(x);
        } else if (x < a[pivot]) {
            newArrayObj = new LinearSortedArray(pivot);
            newArrayObj.count = newArrayObj.a.length;
            newArrayObj.a = copyingMethod(0, pivot, this);
            for (int i = 0; i < newArrayObj.a.length; i++) {
                System.out.print(newArrayObj.a[i]);
                System.out.print(" ");
            }
            System.out.println();
            return newArrayObj.binarySearchRec(x);
        } else {
            return pivot;
        }
    }
}

P.S。：数组已经排序

Answer 1

您可以使用Value Object Pattern来设计单个参数，您可以在其中传递一个＆＃34;包装器＆＃34;对象，但对象有很多字段。

例如：

class SearchParams {
    int target;
    int start;
    int end;  
    SearchParams(t, s, e) {
        target = t;
        start = s;
        end = e'
    }
}

int search(SearchParams params) {
    // some impl
    return search(new SearchParams(params.target, a, b));
}

从技术上讲，这是一个参数。虽然它可能不符合规则的精神。

Answer 2

二进制搜索确实需要范围和目标值 - 所以如果您只传递一个参数，则必须是目标和此必须封装数组＆amp;范围。

public class ArraySegment {
    protected int[] array;
    protected int boundLo;
    protected int boundHi;

    public class ArraySegment (int[] array) {
        // entire array.
        this( array, 0, array.length);
    }
    public class ArraySegment (int[] array, int lo, int hi) {
        this.array = array;
        this.boundLo = lo;
        this.boundHi = hi;
    }

    public int binarySearch (int target) {
        if (boundHi <= boundLo) {
            return -1;         // Empty;  not found.
        }

        int pivot = (boundLo + boundHi) / 2;
        int pivotEl = array[ pivot];
        if (target == pivotEl) {
            return pivot;      // Found!
        }
        if (target < pivotEl) {
            // recurse Left of pivot.
            ArraySegment sub = new ArraySegment( array, boundLo, pivot);
            return sub.binarySearch( target);
        } else {
            // recurse Right of pivot.
            ArraySegment sub = new ArraySegment( array, pivot, boundHi);
            return sub.binarySearch( target);
        }
    }
}

你应该回归什么样的结果有点质疑 - 对于像这样的问题，并没有一个很好的答案，作为一个整数指数＆＃34;有点失败了ArraySegment / range包装器的目的，返回一个只包含找到的值的ArraySegment也是没用的。

PS：你真的不应该复制数组或它的内容，只是将圆引用传递给该数组上的范围。像java.lang.String一样是字符数组的范围。

仅使用1个参数在int数组中进行递归二进制搜索

2 个答案: