计算这个特定算法的时间复杂度

Question

public static String findLongestSubstring(String str) {
for (int len = str.length(); len >= 2; len--) {
    for (int i = 0; i <= str.length() - len; i++) {
        String substr = str.substring(i, i + len);
        int vowels = countVowels(substr);
        int consonants = len - vowels;
        if (vowels == consonants) {
            return substr;
        }
    }
}
return "";
}

private static int countVowels(String str) {
return str.replaceAll("[^AEIOUaeiou]+", "").length(); 
 }

发件人：problem

我的计算：

第一个循环有 (str.length - 1) 个旋转。第二个循环取决于第一个循环，所以它类似于： (0), [0, 1], [0, 1, 2] , ... , [0, 1 .., str.length - 2] 因此这是总共（仅第二个循环）1 + 2 + ... + N - 2 = (2N-3)^2/8 -1/8 ~ (2N)^2。如果我们让 N=str.length。在第一个循环中，我们有 (N-1) ~ N，因此总共有 ~N^3。但是我们必须假设在两个循环内都是 O(1) 否则我们有 > O(N^3)？

但我认为这是不对的。

我们如何计算这样的时间复杂度？

Answer 1

假设n 的长度是str，你会得到：

• 外循环迭代n - 1 次：O(n)
• 内循环迭代 1 到 n - 1 次，因此平均 n / 2 次：O(n)
• replaceAll() 内 countVowels() 迭代超过 2 到 n 个字符，所以平均 n / 2 + 1 次：O(n)
• 总计为 O(n) * O(n) * O(n)，因此：O (n³)

^{注意：substring() 的性能取决于version of Java，所以它要么是O(1)（早期Java）要么是O (n)（后来的 Java）。但是由于 O(1) + O(n) 和 O(n) + O(n) 是两者O(n)，对内循环体的性能没有影响，所以上面的逻辑只考虑replaceAll()的性能。}

---

更新

外循环和内循环组合计算性能的三种方法，不包括在体中发生的情况：

1. O数学：外循环是O(n)，内循环是O(n)，所以总数是O(n) * O(n) = O(n²)

2. 迭代数学：外循环迭代n - 1 次，内循环迭代n / 2 次（平均），所以总数为(n - 1) * (n / 2) = n² / 2 - n / 2。由于只有增长最快的因素才重要，这意味着 O(n²)

3. 迭代总和：对内循环的迭代求和，即1 + 2 + ... + n-1。一个序列的总和可以计算为count * average，平均值可以计算为(min + max) / 2。这意味着average = (1 + n-1) / 2 = n / 2和sum = (n - 1) * (n / 2)，这与我们在上面#2中得到的结果完全相同，所以它是O(n²)

如您所见，O 数学比较简单，因此选择它作为答案。

Answer 2

如果n 是str 的长度。

外部循环可以近似为（如您所做的）O(n)。

内循环也可以近似为 O(n)，因为当length 为0.

因此，如果您不考虑substring 和replaceAll 方法内部发生的情况，那么复杂性是 O(n) * O(n) -> O(n^2)。

---

注意replaceAll 遍历整个字符串，所以他的内部复杂度是 O(n)。考虑到这一点，复杂度为 O(n^3)。