这个程序的运行时和空间复杂度是多少？

Question

Problem Statement: Reverse the words.

Example: perfect makes practice Output: practice makes perfect

I am pretty sure the space complexity is O(n) as I am using StringBuilder but still I wanna be sure. I am learning Runtime complexity and from below I learned that both loops are running for O(n) elements. strB.toString() it internally copies the characters and returns the String which I think is also an O(n) task. The same goes for strB.append(arr[i]) as when the StringBuilder capacity got exhausted it will again call Arrays.copyOf and will create new Character array internally which I think is still O(n).

I am trying to learn run-time and space complexity but sometimes get stuck. I think this whole solution runtime complexity is O(n2), please let me know your views.

Follow up question: If it is O(n2) then it means that we can't use java internal DS methods for solving interview questions?

public class CharReverseAsWords {
public static void main(String[] args) {
    char[] arr = { 'p', 'e', 'r', 'f', 'e', 'c', 't', ' ', 'm', 'a', 'k', 'e', 's', ' ', 'p', 'r', 'a', 'c', 't',
            'i', 'c', 'e' };
    long startTime = System.currentTimeMillis();

    //Creating Stack.
    Deque<String> stk = new ArrayDeque<>();

    StringBuilder strB = new StringBuilder(26);
    for (int i = 0; i < arr.length; i++) {  //O(n)
        if (arr[i] != ' ') {
            strB.append(arr[i]);           //O(n): If capacity is consumed, new array will get created which has O(n) time complexity.
        } else {
            stk.push(strB.toString());      //O(1)
            stk.push(" ");                  //O(1)
            strB = new StringBuilder(26);
        }
    }

    //pushing last string
    stk.push(strB.toString());          //O(1)

    while (!stk.isEmpty()) {            //O(n)
        System.out.print(stk.pop());    //O(1)
    }

    System.out.println();
    System.out.println(System.currentTimeMillis() - startTime + " ms");
}}

Answer 1

As per your code, it would be O(n)+O(n)+O(n) = O(3n) .

for (int i = 0; i < arr.length; i++) {  //O(n)
    // ---- //
}

//pushing last string
stk.push(strB.toString());          //O(n)

while (!stk.isEmpty()) {            //O(n)
    System.out.print(stk.pop());
}

But, when we calculate complexity with n inputs, constants would not affect much . That means, O(3n) would be O(n) by ignoring constants.

Answer 1 : Your programme's Time complexity is O(n)

Answer 2 : There are trade-offs between both. We can use collection framework methods of java in DS problems. But, always we need to think if we can achieve the same with our logic and loop, we should go for that. We can take care of not generating more garbage objects , more computation than necessary and breaking loops as soon as possible kind of points of optimisations. If we go for collection framework, these points may be considered as trade-offs.

A little optimisation in your code would be :

for (int i = 0; i < arr.length; i++) {  //O(n)
    // ---- //

    // On last iteration, we can push last string 
    if(i == arr.length - 1) {
        //pushing last string
        stk.push(strB.toString())
    }
}

Answer 2

This is complexity.
That's why

// time: O(N)
for (int i = 0; i < arr.length; i++)

// space: O(N)
char[] arr
Deque<String> stk