Java：如何计算程序的时间复杂度？

Question

I have the following program. In a case where it has multiple functions, do I combine the time complexity of each or just take the highest order time complexity out of all of them?

I believe the find() has a time complexity of n and isCompound has a time complexity of n has well. Is that correct?

Thank you and will be sure to vote up and accept answer.

private static String[] find(String[] array) {
    Set<String> words = new LinkedHashSet<>(Arrays.asList(array));
    Set<String> otherWords = new HashSet<>(words);
    for (Iterator<String> i = words.iterator(); i.hasNext(); ) {
        String next = i.next();
        otherWords.remove(next);
        if (isCompound(next, otherWords)) {
            i.remove();
        } else {
            otherWords.add(next);
        }
    }
}

private static boolean isCompound(String string, Set<String> otherWords) {
    if (otherWords.contains(string)) {
        return true;
    }
    for (String word : otherWords) {
        if (string.startsWith(word)) {
            return isCompound(string.replaceAll("^" + word, ""), otherWords);
        }
        if (string.endsWith(word)) {
            return isCompound(string.replaceAll(word + "$", ""), otherWords);
        }
    }
    return false;
}

Answer 1

There is nothing like time complexity of a program. We calculate time complexity for algorithms or, in the context of programming, for individual (atomic) functions.

We benchmark programs (which may consist of multiple functions) by measuring their running time in tools like profilers. Imagine if a program contains hundreds of source files, how can you expect to calculate its time complexity?

To analyze the complexities for find and isCompound , we certainly need to know the complexities for the functions called inside them, like otherWords.remove(next) , otherWords.add(next) , string.replaceAll("^" + word, "") or otherWords.contains(string) .

If you know for certain what their complexities are, then we can compute the complexities for your functions. And even if you calculate all the complexities, that too would be an approximation made for very large inputs. So, you decide what you really wish to calculate.

EDIT: To calculate the complexities for your program, I suggest you break down each of the library function you called and try to analyze them. For instance, since otherWords is a HashSet , we can infer that otherWords.contains(string) (lookup operation in a hash table) might take O(1) (big-O) time.