这段代码的时间复杂度是 O(N^2)

Question

这是我针对 leetcode 中的一个问题的解决方案。通过我的推论，我得出结论它具有总体 O(N^2) 时间复杂度。但是，我想对此进行确认，以免在判断算法的时间/空间复杂度时不会继续犯同样的错误。

哦，问题是这样的：

给定一个输入字符串，逐字反转字符串。 例如“我就是你”==“你就是我”

代码如下：-

public String reverseWords(String s) {
        //This solution is in assumption that I am restricted to a one-pass algorithm.
        //This can also be done through a two-pass algorithm -- i.e. split the string and etc.

        if(null == s)
            return "";
        //remove leading and trailing spaces
        s = s.trim();
        int lengthOfString = s.length();
        StringBuilder sb = new StringBuilder();
        //Keeps track of the number of characters that have passed.
        int passedChars = 0;
        int i = lengthOfString-1;
        for(; i >= 0; i--){
            if(s.charAt(i) == ' '){
                //Appends the startOfWord and endOfWord according to passedChars.
                sb.append(s.substring(i+1, (i+1+passedChars))).append(" ");
                //Ignore additional space chars.
                while(s.charAt(i-1) == ' '){
                    i--;
                }
                passedChars = 0;
            }else{
                passedChars++;
            }
        }

        //Handle last reversed word that have been left out.
        sb.append(s.substring(i+1, (i+1+passedChars)));

        //return reversedString;
        return sb.toString();
    }

我认为这是一个 O(N^2) 算法：-

1. 循环 = O(n)
2. StringBuilder.append = O(1)
3. 子字符串方法 = O(n) [从 Java 7 开始]

关于这一点，如果其他人有比这更好的解决方案，请随时分享！ :)

我的目标是一次性解决方案，因此选择在循环之前不拆分字符串。

感谢您的帮助！

编辑：我的意思是询问包含循环的代码部分的时间复杂度。如果问题具有误导性/混淆性，我提前道歉。整个代码块是为了澄清目的。 :)

Answer 1

时间复杂度为O(n)。

每次插入 (append(x)) 到 StringBuilder 都在 O(|x|) 中完成，其中 |x|是您要附加的输入字符串的大小。 （平均而言，独立于构建器的状态）。

您的算法迭代整个字符串，并为其中的每个单词使用String#substring()。由于单词不重叠，这意味着您为每个单词执行一次substring()，并将其附加到构建器（也一次） - 为每个单词提供2|x|x。

总结一下，给你

T(S) = |S| + sum{2|x| for each word x}

但是由于sum{|x| for each word x} <= |S|，这给了你总共：

T(S) = |S| + 2sum{|x| for each word x} = |S| + 2|S| = 3|S|

自从 |S|是输入的大小（n），这是O(n)

---

注意，重要的部分在 jdk7 中，substring() 方法在输出字符串的大小上是线性的，而不是原始的（你只复制相关部分，而不是整个字符串）。

Answer 2

这是一个替代解决方案，我认为它的性能可能会更好。

public String reverseWords(String s) {
    String[] array = s.split(" ");
    int len = array.length;

    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < len; i++) {
        sb.append(" ").append(array[len - i - 1]);
    }

    return sb.toString().trim();
}

Answer 3

Amit 已经给你详细解释了复杂度计算，我想给你一个更简单的版本。

一般来说，如果我们有嵌套循环，我们认为复杂度为 O(N^2)。但情况并非总是如此，因为您必须为输入的每第 n 部分执行 n 次活动。例如，如果您的输入大小为 3，则必须对每个元素执行 3 次操作。然后，您可以说您的算法具有 O(n^2) 复杂度。

由于您只遍历和处理输入字符串的每个部分一次（即使您使用的是嵌套循环），复杂性应该在 O(n) 的数量级上。为了证明，Amit 做得很好。

虽然，我会使用下面的代码来颠倒单词的顺序

String delim = " ";
String [] words = s.split(delim);
int wordCount = words.length; 

for(int i = 0; i < wordCount / 2; i++) {
    String temp = words[i];
    words[i] = words[wordCount - i - 1];
    words[wordCount - i - 1] = temp;
}

String result = Arrays.toString(words).replace(", ", delim).replaceAll("[\\[\\]]", "");