Class declaration syntax in Swift - Time & Space Complexity

Time Complexity: Class declaration syntax

O(n)

Understanding Time Complexity

When we write a class in Swift, it's important to know how the time it takes to create or use that class changes as we add more parts to it.

We want to answer: How does the time to declare and use a class grow when the class has more properties or methods?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Person {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    func greet() {
        print("Hello, my name is \(name)")
    }
}
    

This code defines a simple class with two properties, an initializer, and a method to greet.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: There are no loops or repeated operations inside the class declaration itself.
• How many times: The initializer and method run once per object created or method call, but the class declaration runs once when the program loads.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (number of properties/methods)	Approx. Operations
2	Small, fixed setup time
10	Still small, grows a little
100	More setup work, but still linear growth

Pattern observation: The time to declare a class grows roughly in a straight line as you add more properties or methods.

Final Time Complexity

Time Complexity: O(n)

This means the time to declare a class grows linearly with the number of properties and methods it has.

Common Mistake

[X] Wrong: "Declaring a class always takes the same time no matter how big it is."

[OK] Correct: Adding more properties or methods means more work for the compiler to set up, so the time grows with size.

Interview Connect

Understanding how class size affects setup time helps you write clear and efficient code, a skill that shows you think about how your programs work behind the scenes.

Self-Check

"What if we added inheritance or protocols to the class? How would the time complexity change?"