Weak references to break cycles in Swift - Time & Space Complexity

Time Complexity: Weak references to break cycles

O(n)

Understanding Time Complexity

When using weak references to break cycles, we want to see how this affects the program's speed as data grows.

We ask: How does the program's work change when managing weak references in Swift?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Person {
    let name: String
    weak var apartment: Apartment?
    init(name: String) { self.name = name }
}

class Apartment {
    let unit: String
    var tenant: Person?
    init(unit: String) { self.unit = unit }
}

This code shows two classes referencing each other, where one link is weak to avoid a cycle.

Identify Repeating Operations

Look for repeated actions that affect time.

• Primary operation: Assigning and accessing references between objects.
• How many times: Once per object creation or reference update.

How Execution Grows With Input

As you create more Person and Apartment objects, each link assignment happens once.

Input Size (n)	Approx. Operations
10	About 10 reference assignments
100	About 100 reference assignments
1000	About 1000 reference assignments

Pattern observation: The work grows directly with the number of objects created.

Final Time Complexity

Time Complexity: O(n)

This means the time to manage weak references grows linearly with the number of objects.

Common Mistake

[X] Wrong: "Using weak references makes the program instantly faster or slower regardless of object count."

[OK] Correct: Weak references only affect memory management, not the speed of each reference assignment, which still grows with object count.

Interview Connect

Understanding how weak references affect time helps you explain memory management clearly and shows you can think about program efficiency in real projects.

Self-Check

"What if we replaced the weak reference with a strong one? How would the time complexity and program behavior change?"