Question

我想实现二进制搜索，我有三种方法。我想输出特定因子所需的递归调用量。

因子2表示在每个递归步骤中搜索空间被分成两半。 *因子3意味着搜索空间在每个递归步骤中分为三分之一和三分之二。 *在每种情况下，假定整数除法，这意味着分数向下舍入。

我不知道如何调用列表haystack的特定元素。我应该如何正确实现BinarySearch类的三个方法？如何实现主类输入数字和递归调用的数量？

这是BinarySearch类：

package u8a1;

import java.util.List;

public class BinarySearch<Key extends Comparable<Key>, Value> implements IBinarySearch<Key, Value>, IMeasure {

    public Key key;

    public Value value;

    public BinarySearch() {
        this.key = key;
        this.value = value;
    }
    public Value find(List<Unit<Key, Value>> haystack, Key needle)
    {
        //return haystack.isEmpty() ? null : haystack.get(0).value;
        int m, li, re;
        li = 0;
        re = haystack.size();
        //if ()
        return value;
    }
    /** 
 * Set the factor for the binary search.
 * 
 * A factor of two means that the search space is split into half-half in each recursion step.
 * A factor of three means that the search space is split into one third and two thirds in each recursion step.
 * In each case integer division is assumed, which means fractions are rounded down.
 * 
 * This method is called first after instantiation.
 * 
 * @param factor
 *            an integer value
 */
    public void setFactor(int factor)
    {
        //int m, li, re;
        //li = 0; re = haystack.size();
        //getNumberofCalls()
        return;
    }
    public int getNumberofCalls()
    {
        return 1/* + getNumberofCalls()*/;
    }
}

这是主要课程：

package u8a1;

/**
 * Main class of the Java program. 
 * 
 */
import java.util.Scanner;

//...
class Scan{
    Scanner in = new Scanner(System.in);
    int num = in.nextInt();
}


public class Main {

    public static void main(String[] args) {

        // we print a heading and make it bigger using HTML formatting
        System.out.println("<h4>-- Binaere Suche --</h4>");
        int anzahl = 0;
        //zahl.Scan();
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
    }
}

告诉我你是否需要接口和类Unit，但是在BinarySearch类中我有相同的构造函数。

Answer 1

这里我们有一个搜索操作应该生成两个输出1. value找到2. count。

我认为可以尝试两种方法： -

BinarySearch可以包含factor，list或haystack，key和count的实例变量。要进行搜索，首先要使用带有BinarySearch和list的构造函数创建key的实例。致电setFactor()来设定因素。调用doSearch()或find，不要在list，key实例变量和返回值上运行参数。为每个递归调用运行doSearch()增量count实例变量。一旦doSearch()返回value，请调用getCount()以获取递归调用的数量。有了这个，对于每个要完成的搜索，都应该创建BinarySearch的新实例。
不是从value返回find，而是返回包含response和count的{{1}}对象（如果找到）或null。在开始搜索时，使用count 0和object null创建响应对象。每次递归调用都会传递响应对象。在每个递归调用增量计数开始时，在找到值时返回响应对象一次。 value应在getNumberOfCalls()中定义，并在response返回find时调用。

Answer 2

我被告知如果我想访问haystack的中心元素，我需要编写以下行：

Unit<Key, Value> mid_unit = haystack.get(middle);

现在的问题是将它与具有Key类型的针进行比较。因为当这个工作时，我只需要将搜索到的元素与haystack的中心元素进行比较，然后如果搜索到的元素小于mid_unit，我将正确的限制设置为

right = middle;

，其中

middle = (left + right) / 2;

然后

else left = middle;

Answer 3

这是一个可能的解决方案：

package u8a1;

import java.util.List;
import java.util.ArrayList;

public class BinarySearch<Key extends Comparable<Key>, Value> implements IBinarySearch<Key, Value>, IMeasure {

    private int dividedBy = 2;

    private int numOfCall = 1;

    public Key key;

    public Value value;

    public BinarySearch() {
        this.key = key;
        this.value = value;
    }
    public Value find(List<Unit<Key, Value>> haystack, Key needle)
    {
        if (haystack.size() == 0) return null;
        if (needle.compareTo(haystack.get(haystack.size()/dividedBy).key) == 0) return haystack.get(haystack.size()/dividedBy).value;
        if (haystack.size() == 1) return null;
        else if(needle.compareTo(haystack.get(haystack.size()/dividedBy).key) > 0)
        {
            ++numOfCall;
            return find(haystack.subList((haystack.size()/dividedBy), haystack.size()), needle);
        }
        else if(needle.compareTo(haystack.get(haystack.size()/dividedBy).key) < 0)
        {
            ++numOfCall;
            return find(haystack.subList(0, (haystack.size()/dividedBy)), needle);
        }
        else return null;
    }
    public void setFactor(int factor)
    {
        dividedBy = factor;
    }
    public int getNumberofCalls()
    {
        return numOfCall;
    }
}

二进制搜索实现

3 个答案: