Java 使用Trie在文档中搜索和定位前缀

使用此特定数据结构时遇到的面试问题。我用两个列表解决了这个问题，但他们正在寻找一个Trie的实现。不太熟悉这个数据结构。我有创建节点和向Trie插入单词的基线代码，如果包含前缀，则返回true或false。如何实现不仅返回true，而且返回文档中前缀所在位置的功能？因此，如果提供本文件：

Hello, World! Computer Science is a great major if you enjoy the sciences.

预扩展（“科学”）将返回{24,66} preexposition（“i”）将返回{32,49}

我最初是通过在“”上创建一个拆分文档的列表来实现这一点的。然后循环遍历该列表并创建第二个包含字符位置的列表，方法是对列表中的单词进行计数，为拆分添加1个字符（在空格上）并存储该字符。然后在原始列表中循环，查看元素是否以前缀开头，如果以前缀开头，则返回角色位置列表并获取其位置

在使用Trie时，如何使用某种类型的链表来确定位置

class TrieNode {
    private final Map<Character, TrieNode> children = new HashMap<>();
    private boolean endOfWord;

    Map<Character, TrieNode> getChildren() {
        return children;
    }

    boolean isEndOfWord() {
        return endOfWord;
    }

    void setEndOfWord(boolean endOfWord) {
        this.endOfWord = endOfWord;
    }
}

类三节点{
private final Map children=new HashMap（）；
私有布尔内福德；
映射getChildren（）{
返回儿童；
}
布尔isEndOfWord（）{
返回endoford；
}
void setendoford（布尔endoford）{
this.endoford=endoford；
}
}

class-Trie{
私有三极根；
Trie（）{
根=新的三节点（）；
}
空白插入（字符串字）{
三极电流=根；
for（charl:word.toCharArray（））{
current=current.getChildren（）.computeIfAbsent（l，c->new TrieNode（））；
}
当前值。setendoford（真）；
}
布尔删除（字符串字）{
返回delete（root，word，0）；
}
布尔containsNode（字符串字）{
三极电流=根；
for（int i=0；i对于（int i=0；iYou可以构建后缀树：扩充
trinode
以包含动态大小的数组，例如ArrayList以保存这些索引。
class Trie {
    private TrieNode root;

    Trie() {
        root = new TrieNode();
    }

    void insert(String word) {
        TrieNode current = root;

        for (char l : word.toCharArray()) {
            current = current.getChildren().computeIfAbsent(l, c -> new TrieNode());
        }
        current.setEndOfWord(true);
    }

    boolean delete(String word) {
        return delete(root, word, 0);
    }

    boolean containsNode(String word) {
        TrieNode current = root;

        for (int i = 0; i < word.length(); i++) {
            char ch = word.charAt(i);
            TrieNode node = current.getChildren().get(ch);
            if (node == null) {
                return false;
            }
            current = node;
        }
        return current.isEndOfWord();
    }

    boolean isEmpty() {
        return root == null;
    }

    private boolean delete(TrieNode current, String word, int index) {
        if (index == word.length()) {
            if (!current.isEndOfWord()) {
                return false;
            }
            current.setEndOfWord(false);
            return current.getChildren().isEmpty();
        }
        char ch = word.charAt(index);
        TrieNode node = current.getChildren().get(ch);
        if (node == null) {
            return false;
        }
        boolean shouldDeleteCurrentNode = delete(node, word, index + 1) && !node.isEndOfWord();

        if (shouldDeleteCurrentNode) {
            current.getChildren().remove(ch);
            return current.getChildren().isEmpty();
        }
        return false;
    }

    public boolean find(String word) {
        TrieNode current = root;
        for (int i = 0; i < word.length(); i++) {
            char ch = word.charAt(i);
            TrieNode node = current.getChildren().get(ch);
            if (node == null) {
                return false;
            }
            current = node;
        }
        return current.isEndOfWord();
    }

    public TrieNode searchNode(String str){
        Map<Character, TrieNode> children = root.getChildren();
        TrieNode t = null;
        for(int i=0; i<str.length(); i++){
            char c = str.charAt(i);
            if(children.containsKey(c)){
                t = children.get(c);
                children = t.getChildren();
            }else{
                return null;
            }
        }

        return t;
    }

    public boolean startsWith(String prefix) {
        if(searchNode(prefix) == null)
            return false;
        else
            return true;
    }
}