bobo老师你好，我遇到了一个关于ternary复杂度的问题但是不太能想出来答案

就是现在我有一个叫TernarySearchTreeAutocomplete的class，这个class里面有两个方法，第一个叫addAll是负责把一个Collection（这个collection里面装了很多strings)的里面所有的string添加到ternary tree里，

第二个方法 addMatches, 是用户给一个 prefix，然后找到，树中所有满足这个prefix的string并且返回一个装有所有matches的list：

然后问题是：

第一个问题：

give a big-theta bound for the worst-case runtime of the addAll and allMatches methods for each implementation,with respect to N, the total number of terms currently in the data structure.

题目假定所有传入addAll方法的string的数量和 prefix 都是constant

第二个问题：

class中allmatch 和collect 背后的思路是怎样 的，  collect那个方法我有点没看懂

class具体代码如下：

package autocomplete;

java.util.Collection;
java.util.List;
java.util.LinkedList;
TernarySearchTreeAutocomplete Autocomplete {
    Node ;

    TernarySearchTreeAutocomplete() {
        = ;
    }

    addAll(Collection<? CharSequence> terms) {
        (CharSequence s : terms) {
            (!contains(s)) {
                = add(, s, );
            }
        }
    }

    Node add(Node node, CharSequence key, depth) {
        curr = key.charAt(depth);
        (node == ) {
            node = Node(curr, );
        }
        (curr < node.) {
            node.= add(node., key, depth);
        } (curr > node.) {
            node.= add(node., key, depth);
        } (depth < key.length() - ) {
            node.= add(node., key, depth + );
        } {
            node.= ;
        }
        node;
    }

    contains(CharSequence key) {
        (key == ) {
            NullPointerException();
        } (key.length() == ) {
            IllegalArgumentException();
        }
        Node node = get(, key, );
        node != && node.;
    }

    Node get(Node node, CharSequence key, depth) {
        (node == ) {
            ;
        }
        curr = key.charAt(depth);
        (curr < node.) {
            get(node., key, depth);
        } (curr > node.) {
            get(node., key, depth);
        } (depth < key.length() - ) {
            get(node., key, depth + );
        } {
            node;
        }
    }

    List<CharSequence> allMatches(CharSequence prefix) {
        (prefix == ) {
            NullPointerException();
        } (prefix.length() == ) {
            IllegalArgumentException();
        }
        List<CharSequence> list = LinkedList<>();
        Node node = get(, prefix, );
        (node == ) {
            list;
        }
        (node.) {
            list.add(prefix);
        }
        collect(node., StringBuilder(prefix), list);
        list;
    }

    collect(Node node, StringBuilder prefix, List<CharSequence> list) {
        (node == ) {
            ;
        }
        collect(node., prefix, list);
        (node.) {
            list.add(prefix.toString() + node.);
        }
        prefix.append(node.);
        collect(node., prefix, list);
        prefix.deleteCharAt(prefix.length() - );
        collect(node., prefix, list);
    }
    Node {
        ;
        ;
        Node ;
        Node ;
        Node ;

        Node(data, isTerm) {
            .= data;
            .= isTerm;
            .= ;
            .= ;
            .= ;
        }
    }
}