用于存储按字母顺序排列的单词列表的最有效数据结构

Question

我的程序将读取一段单词（存储在文本文件中）。然后需要执行以下操作：

• 打印出所有单词的列表（按字母顺序）。对于每个单词，打印频率计数（单词在整个段落中出现的次数）和单词出现的行号（不需要排序）。如果一个词在一行出现多次，行号不需要存储两次（这个词的频率计数还是会更新）
• 显示从最频繁到最不频繁排序的单词列表。
• 用户将输入一个特定的单词。如果找到了这个词，打印出它的频率计数。

限制：我不能使用Collections 类，也不能多次存储数据。 （例如，从段落中读取单词并将它们存储到 Set 和 ArrayList 中）

对此进行编码并不难，但我不知道什么是最有效的实现，因为数据大小可能是维基百科文章或其他内容中的几段。这是我现在的想法：

• 有一个 Word 课程。这个 Word 类将包含返回单词的频率计数和该单词出现的行（以及其他相关数据）的方法。
• 段落将存储在文本文件中。程序将逐行读取数据。将一行拆分成一个数组，逐个读入。
• 从文本文件中读入单词时，将单词放入某种结构中。如果结构中不包含单词，则创建一个新的单词对象。
• 如果结构已包含该词，请更新该词的频率计数器。
  • 我还会有一个int 来记录行号。这些行号将相应更新。

这有点不完整，但这是我现在的想法。整个 'Word' 类也可能完全没有必要。

Answer 1

你可以有这样的结构： https://gist.github.com/jeorfevre/946ede55ad93cc811cf8

/**
* 
* @author Jean-Emmanuel je@Rizze.com
*
*/
public class WordsIndex{
        HashMap<String, Word> words = new HashMap<String, Word>();

        public static void put(String word, int line, int paragraph){
            word=word.toLowerCase();

            if(words.containsKey(word)){
                Word w=words.get(word);
                w.count++;

            }else{
                //new word
                Word w = new Word();
                w.count=1;
                w.line=line;
                w.paragraph=paragraph;
                w.word=word;
                words.put(word, w);
            }



        }
    }

    public class Word{
        String word;
        int count;
        int line;
        int paragraph;
    }

享受

Answer 2

你可以使用 TreeMap 它非常适合获取有序的数据。使用您的单词作为键，使用频率作为值。例如让下面是你的段落

Java 是好语言 Java 是面向对象的 所以我将执行以下操作以存储每个单词及其频率

String s = "Java is good language Java is object oriented"   ; 
String strArr [] = s.split(" ") ; 
TreeMap<String, Integer> tm = new TreeMap<String, Integer>();
for(String str : strArr){
   if(tm.get(str) == null){
         tm.put(str, 1) ; 
   }else{
        int count = tm.get(str) ; 
        count+=1 ; 

   }
}

希望对你有帮助

Answer 3

您可以使用简单的TreeMap<String, Integer> 进行频率查找。

查找应该是 O(1)，因为单词很短（即你会找到一个正常的文本）。如果您预计会有很多不成功的查找（大量搜索不存在的词），您可以使用布隆过滤器进行预过滤。

我将从一个简单的实现开始，并在需要时进一步优化（直接解析流，而不是用分隔符分割每一行并重复）。

Answer 4

首先，您可以创建一个类来保存出现次数和行号（连同单词）的数据。这个类可以实现Comparable接口，提供基于词频的简单比较：

public class WordOccurrence implements Comparable<WordOccurrence> {

    private final String word;
    private int totalCount = 0;
    private Set<Integer> lineNumbers = new TreeSet<>();

    public WordOccurrence(String word, int firstLineNumber) {
        this.word = word;
        addOccurrence(firstLineNumber);
    }

    public final void addOccurrence(int lineNumber) {
        totalCount++;
        lineNumbers.add(lineNumber);
    }

    @Override
    public int compareTo(WordOccurrence o) {
        return totalCount - o.totalCount;
    }

    @Override
    public String toString() {
        StringBuilder lineNumberInfo = new StringBuilder("[");
        for (int line : lineNumbers) {
            if (lineNumberInfo.length() > 1) {
                lineNumberInfo.append(", ");
            }
            lineNumberInfo.append(line);
        }
        lineNumberInfo.append("]");
        return word + ", occurences: " + totalCount + ", on rows "
                + lineNumberInfo.toString();
    }
}

从文件中读取单词时，将数据返回到Map<String, WordOccurrence> 中很有用，将单词映射到WordOccurrences。使用TreeMap，您将“免费”获得按字母顺序排序。此外，您可能希望从行中删除标点符号（例如，使用像 \\p{P} 这样的正则表达式）并忽略单词的大小写：

public TreeMap<String, WordOccurrence> countOccurrences(String filePath)
        throws IOException {
    TreeMap<String, WordOccurrence> words = new TreeMap<>();

    File file = new File(filePath);
    BufferedReader reader = new BufferedReader(new InputStreamReader(
            new FileInputStream(file)));
    String line = null;
    int lineNumber = 0;

    while ((line = reader.readLine()) != null) {
        // remove punctuation and normalize to lower-case
        line = line.replaceAll("\\p{P}", "").toLowerCase();
        lineNumber++;
        String[] tokens = line.split("\\s+");
        for (String token : tokens) {

            if (words.containsKey(token)) {
                words.get(token).addOccurrence(lineNumber);
            } else {
                words.put(token, new WordOccurrence(token, lineNumber));
            }
        }
    }

    return words;
}

使用上面的代码按字母顺序显示出现的次数就像

for (Map.Entry<String, WordOccurrence> entry :
         countOccurrences("path/to/file").entrySet()) {
        System.out.println(entry.getValue());
}

如果您不能使用Collections.sort()（和Comparator<WordOccurrence>）按出现次数排序，则需要自己编写排序。应该这样做：

public static void displayInOrderOfOccurrence(
        Map<String, WordOccurrence> words) {

    List<WordOccurrence> orderedByOccurrence = new ArrayList<>();

    // sort
    for (Map.Entry<String, WordOccurrence> entry : words.entrySet()) {
        WordOccurrence wo = entry.getValue();

        // initialize the list on the first round
        if (orderedByOccurrence.isEmpty()) {
            orderedByOccurrence.add(wo);
        } else {

            for (int i = 0; i < orderedByOccurrence.size(); i++) {
                if (wo.compareTo(orderedByOccurrence.get(i)) > 0) {
                    orderedByOccurrence.add(i, wo);
                    break;
                } else if (i == orderedByOccurrence.size() - 1) {
                    orderedByOccurrence.add(wo);
                    break;
                }
            }
        }
    }

    // display
    for (WordOccurrence wo : orderedByOccurence) {
        System.out.println(wo);
    }
}

使用以下测试数据运行上述代码：

土豆;橘子。 香蕉;苹果，苹果；土豆。 土豆。

将产生这个输出：

苹果，出现次数：2，在行 [2] 香蕉，出现次数：1，在行 [2] 橙色，出现次数：1，在行 [1] 马铃薯，出现次数：3，在行 [1, 2, 3] 马铃薯，出现次数：3，在行 [1, 2, 3] 苹果，出现次数：2，在行 [2] 香蕉，出现次数：1，在行 [2] 橙色，出现次数：1，在行 [1]