算法，大O表示法：这个函数是O（n ^ 2）吗？ 还是O（n）？

Question

This is code from a algorithm book, "Data structures and Algorithms in Java, 6th Edition." by by Michael T. GoodRich, Roberto Tamassia, and Michael H. Goldwasser

public static String repeat1(char c, int n)
{
    String answer = "";
    for(int j=0; j < n; j++)
    {
         answer += c;
    }  
    return answer;
}

According to the authors, the Big O notation of this algorithm is O(n^2) with reason: "The command, answer += c, is shorthand for answer = (answer + c). This command does not cause a new character to be added to the existing String instance; instead it produces a new String with the desired sequence of characters, and then it reassigns the variable, answer, to refer to that new string. In terms of efficiency, the problem with this interpretation is that the creation of a new string as a result of a concatenation, requires time that is proportional to the length of the resulting string. The first time through this loop, the result has length 1, the second time through the loop the result has length 2, and so on, until we reach the final string of length n."

However, I do not understand, how this code can have O(n^2) as its number of primitive operations just doubles each iteration regardless of the value of n(excluding j < n and j++). The statement answer += c requires two primitive operations each iteration regardless of the value n, therefore I think the equation for this function supposed to be 4n + 3. (Each loop operates j

Or, is the sentence,"In terms of efficiency, the problem with this interpretation is that the creation of a new string as a result of a concatenation, requires time that is proportional to the length of the resulting string.," just simply saying that creating a new string as a result of a concatenation requires proportional time to its length regardless of the number of primitive operations used in the function? So the number of primitive operations does not have big effects on the running time of the function because the built-in code for concatenated String assignment operator's running time runs in O(n^2).

How can this function be O(n^2)?

Thank you for your support.

Answer 1

During every iteration of the loop, the statement answer += c; must copy each and every character already in the string answer to a new string.

Eg n = 5, c = '5'

• First loop: answer is an empty string, but it must still create a new string. There is one operation to append the first '5' , and answer is now "5" .
• Second loop: answer will now point to a new string, with the first '5' copied to a new string with another '5' appended, to make "55" . Not only is a new String created, one character '5' is copied from the previous string and another '5' is appended. Two characters are appended.
• "n"th loop: answer will now point to a new string, with n - 1 '5' characters copied to a new string, and an additional '5' character appended, to make a string with n 5s in it.

The number of characters copied is 1 + 2 + ... + n = n(n + 1)/2. This is O(n ² ).

The efficient way to constructs strings like this in a loop in Java is to use a StringBuilder , using one object that is mutable and doesn't need to copy all the characters each time a character is appended in each loop. Using a StringBuilder has a cost of O(n).

Answer 2

Strings are immutable in Java. I believe this terrible code is O(n^2) for that reason and only that reason. It has to construct a new String on each iteration. I'm unsure if String concatenation is truly linearly proportional to the number of characters (it seems like it should be a constant time operation since Strings have a known length). However if you take the author's word for it then iterating n times with each iteration taking a time proportional to n, you get n^2. StringBuilder would give you O(n).

Answer 3

I mostly agree with it being O(n^2) in practice, but consider:

Java is SMART. In many cases it uses StringBuilder instead of string for concatenation under the covers. You can't just assume it's going to copy the underlying array every time (although it almost certainly will in this case).

Java gets SMARTER all the time. There is no reason it couldn't optimize that entire loop based on StringBuilder since it can analyze all your code and figure out that you don't use it as a string inside that loop.

Further optimizations can happen--Strings currently use an array AND an length AND a shared flag (And maybe a start location so that splits wouldn't require copying, I forget, but they changed that split implementation anyway)--so appending into an oversized array and then returning a new string with a reference to the same underlying array but a higher end without mutating the original string is altogether possible (by design, they do stuff like this already to a degree)...

So I think the real question is, is it a great idea to calculate O() based on a particular implementation of a language-level construct?

And although I can't say for sure what the answer to that is, I can say it would be a REALLY BAD idea to optimize on the assumption that it was O(n^2) unless you absolutely needed it--you could take away java's ability to speed up your code later by hand optimizing today.

ps. this is from experience. I had to optimize some java code that was the UI for a spectrum analyzer. I saw all sorts of String+ operations and figured I'd clean them all up with .append(). It saved NO time because Java already optimizes String+ operations that are not in a loop.

Answer 4

The complexity becomes O(n^2) because each time the string increase the length by one and to create it each time you need n complexity. Also, the outer loop is n in complexity. So the exact complexity will be (n * (n+1))/2 which is O(n^2)

For example,

For abcdefg

a // one length string object is created so complexity is 1
ab // similarly complexity is 2
abc // complexity 3 here 
abcd // 4 now.
abcde // ans so on.
abcdef
abcedefg

Now, you see the total complexity is 1 + 2 + 3 + 4 + ... + n = (n * (n+1))/2. In big O notation it's O(n^2)

Answer 5

That is because:

answer += c;

is a String concatenation. In java Strings are immutable .

It means concatenated string is created by creating a copy of original string and appending c to it. So a simple concatenation operation is O(n) for n sized String .

In first iteration, answer length is 0 , in second iteration its 1 , in third its 2 and so on.

So you're doing these operations every time ie

1 + 2 + 3 + ... + n = O(n^2)

For string manipulations StringBuilder is the preferred way ie it appends any character in O(1) time.

Answer 6

将字符串的长度视为“n”，因此每次我们需要在末尾添加元素时，字符串的迭代为“n”，并且我们还有外部for循环，因此“n”为此，因此结果我们得到O（n ^ 2）。