Java 在字符串数组上实现二进制搜索

我在这方面有点麻烦。输入数组基于文件输入，数组的大小由文件中的第一行指定。binarySearch方法看起来不错，但似乎不起作用。有人能帮忙吗？谢谢

public static int binarySearch(String[] a, String x) {
    int low = 0;
    int high = a.length - 1;
    int mid;

    while (low <= high) {
        mid = (low + high) / 2;

        if (a[mid].compareTo(x) < 0) {
            low = mid + 1;
        } else if (a[mid].compareTo(x) > 0) {
            high = mid - 1;
        } else {
            return mid;
        }
    }

    return -1;
}

public static void main(String[] args) {

    Scanner input = new Scanner(System.in);

    System.out.println("Enter the name of your file (including file extension): ");
    String filename = input.next();

    String[] numArray;
    try (Scanner in = new Scanner(new File(filename))) {
        int count = in.nextInt();

        numArray = new String[count];

        for (int i = 0; in.hasNextInt() && count != -1 && i < count; i++) {
            numArray[i] = in.nextLine();
        }

        for (int i = 0; i < count; i++) //printing all the elements
        {
            System.out.println(numArray[i]);
        }

        String searchItem = "The";

        System.out.println("The position of the String is:");
        binarySearch(numArray, searchItem);

    } catch (final FileNotFoundException e) {
        System.out.println("That file was not found. Program terminating...");
        e.printStackTrace();

    }

}

publicstaticintbinarysearch（字符串[]a，字符串x）{
int低=0；
int高=a.长度-1；
int mid；
while（低0）{
高=中-1；
}否则{
中途返回；
}
}
返回-1；
}
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（System.in）；
System.out.println（“输入文件名（包括文件扩展名）：”；
字符串文件名=input.next（）；
字符串[]numaray；
try（Scanner in=new Scanner（新文件（文件名）））{
int count=in.nextInt（）；
numArray=新字符串[计数]；
对于（int i=0；in.hasNextInt（）&&count！=-1&&i

我认为您的问题在于忘记输出结果。尝试替换binarySearch（numArray，searchItem）System.out.println（二进制搜索（numArray，searchItem））

除了前面提到的缺少打印结果外，我还可以发现四个问题

1:您有一个名为

numArray

的

String[]

，您正在搜索一个

String

，

“

名称

numArray

可能有点不正确

2：我假设您有某种指定的输入文件格式，其中文件中的

字符串的数量由
整数指定为文件中的第一个标记。但是，这是正常的，作为填充
numArray
的for循环中的一个条件，
在.hasNextInt（）
中存在
，下一个标记使用
在.nextLine（）中
从
扫描仪中取出。您应该使用补充检查/删除方法，例如.hasNext（）中的
in
与.next（）中的
in
。查看
扫描仪

3:binarySearch（String[]，String）
方法使用
String.compareTo（String）
。这决定了该
字符串
到参数
字符串
的字典顺序。尝试比较大写和小写可能不会产生您期望的结果，因为“.compareTo”（“the”）
”不会产生
0
。您应该查看
字符串
，以获取选项，可以在读取文件时将所有输入强制为一个大小写，也可以使用不同风格的compare-to方法

4：我看到的最后一件事可能被认为是一个小问题，但是如果有一个足够大的
字符串
数组，以及一个可能位于数组右侧（即高索引侧）的搜索字符串，您可能会得到一个
ArrayIndexOutOfBoundsException
。这是因为
（低+高）
会导致负值，而结果“应该”大于
整数。最大值
。然后将结果除以2，仍然得到负值。这可以通过对结果进行位移位来解决，而不是除以2，
（低+高）>>1
。Joshua Bloch对分治算法中的这一常见缺陷有很好的理解。
我添加了以下示例供您进一步参考

import java.util.Arrays;

public class BinaryStringSearch {

    public static void main(String[] args) {

        String array[] ={"EWRSFSFSFSB","BB","AA","SDFSFJ","WRTG","FF","ERF","FED","TGH"};
        String search = "BB";

        Arrays.sort(array);

        int searchIndex = binarySearch(array,search);

        System.out.println(searchIndex != -1 ? array[searchIndex]+ " - Index is "+searchIndex : "Not found");
    }

    public static int binarySearch(String[] a, String x) {
        int low = 0;
        int high = a.length - 1;
        int mid;

        while (low <= high) {
            mid = (low + high) / 2;

            if (a[mid].compareTo(x) < 0) {
                low = mid + 1;
            } else if (a[mid].compareTo(x) > 0) {
                high = mid - 1;
            } else {
                return mid;
            }
        }

        return -1;
    }

}

导入java.util.array；
公共类二进制字符串搜索{
公共静态void main（字符串[]args）{
字符串数组[]={“EWRSFSSB”、“BB”、“AA”、“SDFSFJ”、“WRTG”、“FF”、“ERF”、“FED”、“TGH”}；
字符串搜索=“BB”；
数组。排序（数组）；
int searchIndex=binarySearch（数组，搜索）；
System.out.println（searchIndex！=-1？数组[searchIndex]+“-索引为”+searchIndex:“未找到”）；
}
公共静态int二进制搜索（字符串[]a，字符串x）{
int低=0；
int高=a.长度-1；
int mid；
while（低0）{
高=中-1；
}否则{
中途返回；
}
}
返回-1；
}
}
我希望这将有助于：

 public static void main(String ar[]){

    String str[] = {"account","angel","apple","application","black"};
    String search= "application";
    int length = str.length-1;
    BinarySearchInString findStrin = new BinarySearchInString();
    int i = findStrin.find(str, 0, length, search);
    System.out.println(i);
}

  public int find(String first[], int start, int end, String searchString){
    int mid = start + (end-start)/2;

    if(first[mid].compareTo(searchString)==0){
        return mid;
    }
    if(first[mid].compareTo(searchString)> 0){
        return find(first, start, mid-1, searchString);
    }else if(first[mid].compareTo(searchString)< 0){
        return find(first, mid+1, end, searchString);
    }
    return -1;
  }

publicstaticvoidmain（字符串ar[]{
字符串str[]={“帐户”、“天使”、“苹果”、“应用程序”、“黑色”}；
String search=“应用程序”；
int-length=str.length-1；
BinarySearchInString findStrin=新的BinarySearchInString（）；
int i=findStrin.find（str，0，长度，搜索）；
系统输出打印LN（i）；
}
public int find（字符串优先[]，int开始，int结束，字符串搜索字符串）{
int mid=开始+（结束-开始）/2；
如果（第一个[mid].compareTo（搜索字符串）==0）{
中途返回；
}
如果（第一个[mid]。比较（搜索字符串）>0）{
返回find（first、start、mid-1、searchString）；
}else if（第一个[mid]。比较到（搜索字符串）<0）{
返回find（first，mid+1，end，searchString）；
}
返回-1；
}
正如@Mike Rylander发现的那样，您忘记了输出结果

您应该使用而不是自己的实现

（一般来说，JRE库经过了良好的测试，文档齐全，速度很快。我在谷歌上搜索了“java二进制搜索”，这个问题的排名也很好。我尝试了@Thusita Indunil的代码，但似乎不起作用。我更努力地搜索，找到了
数组。binarySearch
，效果很好。）
调用
binarySearch
时，数组是否按排序顺序排列？是。当数组中的元素被打印出来时，它们都显示为null f