Java 查找数组中单词之间的最小距离

例如：

WordDistanceFinder=新建 WordDistanceFinder（Arrays.asList（“the”、“quick”、“brown”、“fox”）， "快速"),

断言（finder.distance（“fox”，“the”）==3）

断言（finder.distance（“quick”、“fox”）==1）

我有下面的解决方案，看起来是O（n），但我不确定是否有更好的解决方案。有人有什么想法吗

String targetString = "fox";
String targetString2 = "the";
double minDistance = Double.POSITIVE_INFINITY;
for(int x = 0; x < strings.length; x++){
    if(strings[x].equals(targetString)){
        for(int y = x; y < strings.length; y++){
            if(strings[y].equals(targetString2))
                if(minDistance > (y - x))
                    minDistance = y - x;
        }
        for(int y = x; y >=0; y--){
            if(strings[y].equals(targetString2))
                if(minDistance > (x - y))
                    minDistance = x - y;
        }
    }
}

String targetString=“fox”；
字符串targetString2=“the”；
双心距离=双正无限；
对于（int x=0；x（y-x））
minDistance=y-x；
}
对于（int y=x；y>=0；y--）{
if（字符串[y].equals（targetString2））
如果（minDistance>（x-y））
minDistance=x-y；
}
}
}

您的解决方案是

O（N^2）

，因为您在查找每个单词时遍历整个列表。 首先找到第一个单词，然后再次遍历整个列表以找到第二个单词

您可以使用两个变量跟踪每个单词的位置，并通过列表=>

O（N）

计算距离

int index1=-1；
int index2=-1；
int minDistance=Integer.MAX_值；
int-tempdance=0；
对于（int x=0；x

导入java.util.*；
公共类字距{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
字符串s=in.nextLine（）；
字符串s1=in.nextLine（）；
字符串s2=in.nextLine（）；
int index1=-1；
int index2=-1；
布尔flag1=假；
布尔标志2=假；
int距离=整数最大值；
int answer=整数最大值；
字符串[]sarray=s.split（“”）；
对于（int i=0；i求给定段落中两个单词之间最小距离的更好且简单的解决方案

    String[] strArray = {"the","quick","brown","fox","quick"};
    String str1 = "quick";
    String str2 = "fox";
    int i,startIndex=0,minDistnace=100;
    for( i=0;i<strArray.length;i++){
        if(strArray[i].equals(str1)||strArray[i].equals(str2)){
            startIndex = i;         //get the first occurence of either word
            break;
        }
    }
    for(;i<strArray.length;i++){
        if(strArray[i].equals(str1)||strArray[i].equals(str2)){
            //compare every word from that first occurence 
            // if words not same and distance less than minimun distance then update
            if(!strArray[i].equals(strArray[startIndex]) && (i-startIndex)<minDistance){
                minDistance = i-startIndex;
                startIndex =i;
            }
            else{
                startIndex =i;
            }
        }
    }
    System.out.println(minDistance);

String[]strArray={“the”，“quick”，“brown”，“fox”，“quick”}；
字符串str1=“快速”；
字符串str2=“fox”；
int i，startIndex=0，mindistance=100；
对于（i=0；i
函数findMinimumWordDistance（字、字A、字B）{
var-wordAIndex=null；
var-wordBIndex=null；
var minDinstance=null；
for（var i=0，length=words.length；idistance）{
minDinstance=距离；
} 
}
}
返回minDinstance；
}
只需一次迭代。
非常简单的解决方案
假设：str1和str2不为null，str1不等于str2，strs不包含null

    private static int findShortestDistance(String str1, String str2, String[] strs) {
        int distance = Integer.MAX_VALUE;
        String temp = null;
        int index = 0;
        for(int i=0; i<strs.length; ++i) {
          if(str1.equals(strs[i]) || str2.equals(strs[i])) {
             if(temp != null && !strs[i].equals(temp)) {
                distance = Math.min(distance, i - index);
             }
             temp = strs[i];
             index = i;
           }
        }
     return distance;
    }

private static int findShortestDistance（字符串str1、字符串str2、字符串[]strs）{
int距离=整数最大值；
字符串temp=null；
int指数=0；
对于（int i=0；它的解决方案是O（n^2）--你有嵌套的
for
循环。是的，这可以在O（n）中完成，但我非常确定这是家庭作业，所以我现在只想说这些。这是一个面试问题。一个主要问题：单词可以出现多次（查看示例问题实例）一个很小的问题：因为你写了<代码>，如果不是<代码> >而不是<代码> > ，如果<代码>目标字符串＝TraceStRe2[/COD> >，这将不起作用。如果单词被允许出现不止一次，那么它的实现基于如何处理这一点，如选择重复项作为开始/结束。我不确定您为什么给我一个-1作为起始项，示例包含“quick”两次。但更一般地说，如果给你一个问题描述，你不能只假设问题中没有给出的约束！我给你-1是因为你的代码有时给出错误的答案——特别是，当两个输入字最近的出现不是每一个的最后一次出现时。差不多了，但是初始化
minDi站姿
to-1不起作用，因为如果
，那么你的最后一个
if将永远不会为真。另外，你为什么要使用
double
？
    String[] strArray = {"the","quick","brown","fox","quick"};
    String str1 = "quick";
    String str2 = "fox";
    int i,startIndex=0,minDistnace=100;
    for( i=0;i<strArray.length;i++){
        if(strArray[i].equals(str1)||strArray[i].equals(str2)){
            startIndex = i;         //get the first occurence of either word
            break;
        }
    }
    for(;i<strArray.length;i++){
        if(strArray[i].equals(str1)||strArray[i].equals(str2)){
            //compare every word from that first occurence 
            // if words not same and distance less than minimun distance then update
            if(!strArray[i].equals(strArray[startIndex]) && (i-startIndex)<minDistance){
                minDistance = i-startIndex;
                startIndex =i;
            }
            else{
                startIndex =i;
            }
        }
    }
    System.out.println(minDistance);

function findMinimumWordDistance(words, wordA, wordB) {
  var wordAIndex = null;
  var wordBIndex = null;
  var minDinstance = null;

  for (var i = 0, length = words.length; i < length; i++ ) {
    if (words[i] === wordA) {
      wordAIndex = i;
    }

    if (words[i] === wordB) {
      wordBIndex = i;
    }

    if ( wordAIndex !== null && wordBIndex !== null ) {
      var distance = Math.abs(wordAIndex - wordBIndex);
      if(minDinstance === null || minDinstance > distance) {
        minDinstance = distance;
      } 
    }
  }
  return minDinstance;
}

    private static int findShortestDistance(String str1, String str2, String[] strs) {
        int distance = Integer.MAX_VALUE;
        String temp = null;
        int index = 0;
        for(int i=0; i<strs.length; ++i) {
          if(str1.equals(strs[i]) || str2.equals(strs[i])) {
             if(temp != null && !strs[i].equals(temp)) {
                distance = Math.min(distance, i - index);
             }
             temp = strs[i];
             index = i;
           }
        }
     return distance;
    }