Question

我有一个LinkedList，其中每个节点都包含一个单词。我还有一个包含6个随机生成的字母的变量。我有一个代码，确定这些字母的所有可能的字母组合。我需要遍历链表并确定最佳匹配＆＃34;在节点中。

示例：

- 生成信件：jghoot

- 链接列表包含：猫，狗，牛，战利品，警报器，ghlooter（我知道ghlooter不是一个字）

该方法将返回警报器，因为它共享最多的字符并且与它最相似。有什么想法吗？

我想你可以说我正在寻找生成的字母是。的子字符串。

Answer 1

使用嵌套的for循环，将原始字符串的每个字母与您要比较的字母进行比较，并为每个匹配增加一个本地int变量。在循环结束时，将local int变量与包含＆＃34; best＆＃34;的全局int变量进行比较。匹配到那一个，如果更大，将local int存储到全局一个，并将您找到的节点放入全局节点。最后你应该有一个匹配最接近的节点。

类似这样的事情

    int currBest = 0;
    int currBestNode = firstNodeOfLinkedList;

    while(blabla)
    {
    int localBest = 0;
    for(i= 0; i < currentNodeWord.length; i++)
    {

       for(j=0; j < originalWord.length;j++)
       {
           if(currentNodeWord[i] == originalWord[j])
            {
                 localBest++
            }

       }
    }
    if(localBest > currBest)
    {
      currBest = localBest;
      currBestNode = currentNodeStringBeingSearched;
    }
    }

//这里你没有你的循环，你的currBestNode应该被设置为找到的最佳匹配。

希望有所帮助

Answer 2

如果您只考虑字符数，首先需要一种方法来计算单词中的字符

public int [] getCharCounts(String word) {
    int [] result = new int['z' - 'a' + 1];
    for(int i = 0; i<word.length(); i++) result[word.charAt(i) - 'a']++;
    return result;
}

然后你需要比较两个单词的字符数

public static int compareCounts(int [] count1, int [] count2) [
    int result = 0;
    for(int i = 0; i<count1.length; i++) {
            result += Math.min(count1[i], count2[i]);
    }
    return result;
}


public static void main(String[] args) {
    String randomWord = "jghoot";
    int [] randomWordCharCount = getCharCounts(randomWord);
    ArrayList<String> wordList = new ArrayList();
    String bestElement = null;
    int bestMatch = -1;
    for(String word : wordList) {
            int [] wordCount = getCharCounts(word);
            int cmp = compareCounts(randomWordCharCount, wordCount);
            if(cmp > bestMatch) {
                    bestMatch = cmp;
                    bestElement = word;
            }
    }
    System.out.println(word);
}

Answer 3

我认为这很有效。

import java.util.*;
import java.io.*;

class LCSLength
{
    public static void main(String args[])
    {
        ArrayList<String> strlist=new ArrayList<String>();
        strlist.add(new String("cat"));
        strlist.add(new String("cow"));
        strlist.add(new String("hooter"));
        strlist.add(new String("dog"));
        strlist.add(new String("loot"));
        String random=new String("jghoot"); //Your String
        int maxLength=-1;
        String maxString=new String();
        for(String s:strlist)
        {
            int localMax=longestSubstr(s,random);
            if(localMax>maxLength)
            {
                maxLength=localMax;
                maxString=s;
            }
        }
        System.out.println(maxString);
    }

public static int longestSubstr(String first, String second) {
    if (first == null || second == null || first.length() == 0 || second.length() == 0) {
        return 0;
    }

    int maxLen = 0;
    int fl = first.length();
    int sl = second.length();
    int[][] table = new int[fl+1][sl+1];

    for(int s=0; s <= sl; s++)
      table[0][s] = 0;
    for(int f=0; f <= fl; f++)
      table[f][0] = 0;




    for (int i = 1; i <= fl; i++) {
        for (int j = 1; j <= sl; j++) {
            if (first.charAt(i-1) == second.charAt(j-1)) {
                if (i == 1 || j == 1) {
                    table[i][j] = 1;
                }
                else {
                    table[i][j] = table[i - 1][j - 1] + 1;
                }
                if (table[i][j] > maxLen) {
                    maxLen = table[i][j];
                }
            }
        }
    }
    return maxLen;
}
}

致谢：维基百科最长的共同子串算法。

http://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Longest_common_substring

搜索LinkedList，比较两个＆＃34;字符串＆＃34;？

3 个答案: