Java 对于以下用例，什么可以更快地实现trie？

我试图解决这个问题，本质上我们需要从字典中找到所有具有给定前缀的单词，按照字典顺序排列

我正在使用Trie数据结构来完成任务，但我的解决方案在判断时超时，有什么更有效/更快的方法来解决这个问题

我当前的实现是

class trie{
    node root=new node();
    class node{
        node child[]=new node[26];
        boolean is_leaf=false;
    }

    public void add(char c[])
    {
        node root=this.root;
        int pos=0,c1=0;
        while(pos<c.length)
        {
            c1=c[pos]-'a';
            if(root.child[c1]==null)
            {
                root.child[c1]=new node();
            }
            root=root.child[c1];
            pos++;
        }
        root.is_leaf=true;
    }
    public ArrayList<String> search(String s)
    {
        char c[]=s.toCharArray();
        node root=this.root;
        int pos=0,c1=0;
        while(pos<c.length)
        {
            c1=c[pos]-'a';
            if(root.child[c1]==null)
            {
                root.child[c1]=new node();
            }
            root=root.child[c1];
            pos++;
        }
        ArrayList<String> ans=new ArrayList<>();
        build_recursive(root,s,new StringBuilder(),ans);
        return ans;

    }
    public void build_recursive(node root,String prefix,StringBuilder cur, ArrayList<String> ans)
    {
        if(root.is_leaf&&cur.length()!=0)
        {
            String s=prefix+cur.toString();
            ans.add(s);
        }

        for(int i=0;i<26;i++)
        {
            if(root.child[i]!=null)
            {
                char c=(char) (i+'a');
                cur.append(c);
                build_recursive(root.child[i], prefix, cur, ans);
                cur.deleteCharAt(cur.length()-1);

            }
        }
    }

}

class-trie{
节点根=新节点（）；
类节点{
节点子节点[]=新节点[26]；
布尔值为_leaf=false；
}
公共无效添加（字符c[]
{
节点根=this.root；
int pos=0，c1=0；
while（pos尝试在查找另一个字符串的子字符串时非常有用。但是，您正在字典中搜索单词-子字符串匹配并不是真正必要的。此外，一旦您找到带有前缀的第一个单词，下一个单词（如果存在）将正好在它旁边。无需复杂的搜索

尝试还从节点中构建了大量开销，然后需要用指针（=额外的空间需求）来引用。指针是慢的。在C++中，迭代链表比迭代数组重复，除非节点都是整齐有序的。
这个问题很可能可以通过以下方式解决：

将所有单词读入字符串的数组列表：O（n），其中n=单词
排序ArrayList:O（n日志n）
对于每个前缀查询，

用于查找前缀O（logn）的第一个匹配项，并且它已在标准库中实现
返回在匹配项用尽之前匹配的连续元素：O（m），m=匹配数


这比在理论复杂性上的尝试要快得多，而且由于内存布局的原因，速度要快得多——在不需要的情况下弄乱指针是很昂贵的。
尝试可以很好地找到另一个字符串的子字符串。但是，您正在字典中搜索单词，子字符串匹配并不是真正必要的。而且，一旦找到带前缀的第一个单词，即下一个单词（如果存在）将位于其旁边。无需复杂搜索

尝试还从节点中构建了大量开销，然后需要用指针（=额外的空间需求）来引用。指针是慢的。在C++中，迭代链表比迭代数组重复，除非节点都是整齐有序的。
这个问题很可能可以通过以下方式解决：

将所有单词读入字符串的数组列表：O（n），其中n=单词
排序ArrayList:O（n日志n）
对于每个前缀查询，

用于查找前缀O（logn）的第一个匹配项，并且它已在标准库中实现
返回在匹配项用尽之前匹配的连续元素：O（m），m=匹配数


这比在理论复杂性上的尝试要快，而且由于内存布局的原因，速度要快得多——在不需要的时候弄乱指针是很昂贵的。
提示：对于工作代码，您最好求助于codereview.stackexchangec.om。您知道-所以是帮助解决特定问题，而不是解决问题“请阅读我的代码，编译它，运行它，并建议如何改进它”这类问题。我投票结束这个问题，因为提问者正在寻找代码改进建议。旁注：请阅读一些java编码风格指南。类以大写字母开头；否”_“在方法名称中。@Jägermeister另一方面，OP的算法对于OP的问题来说确实不是一个好主意。去stackoverflow！@tucuxi，因此是“glib”。提示：对于工作代码，您最好转到codereview.stackexchangec.om。您知道-这是关于帮助解决特定问题，而不是解决问题“请阅读我的代码，编译它，运行它，并建议如何改进它”这类问题。我投票结束这个问题，因为提问者正在寻找代码改进建议。旁注：请阅读一些java编码风格指南。类以大写字母开头；否”_“在方法名中。@Jägermeister另一方面，OP的算法对于OP的问题来说真的不是一个好主意。去stackoverflow！@tucuxi，因此”glib“