Unowned references for guaranteed lifetime in Swift - Time & Space Complexity

Time Complexity: Unowned references for guaranteed lifetime

O(1)

Understanding Time Complexity

When using unowned references in Swift, it's important to understand how the program's work changes as the number of objects grows.

We want to see how the time to access or use unowned references scales with more objects involved.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Owner {
    var name: String
    init(name: String) { self.name = name }
}

class Dependent {
    unowned let owner: Owner
    init(owner: Owner) { self.owner = owner }
    func printOwnerName() {
        print(owner.name)
    }
}

let owner = Owner(name: "Alice")
let dependent = Dependent(owner: owner)
dependent.printOwnerName()
    

This code creates an owner and a dependent object where the dependent holds an unowned reference to the owner, then prints the owner's name.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing the unowned reference to get the owner's name.
• How many times: Once per call to printOwnerName(), no loops or recursion involved.

How Execution Grows With Input

Since there is no loop or repeated traversal, the time to access the unowned reference stays the same no matter how many objects exist.

Input Size (n)	Approx. Operations
10	1 access
100	1 access
1000	1 access

Pattern observation: The operation count stays constant regardless of input size.

Final Time Complexity

Time Complexity: O(1)

This means accessing an unowned reference takes the same amount of time no matter how many objects are involved.

Common Mistake

[X] Wrong: "Accessing unowned references gets slower as more objects exist."

[OK] Correct: Accessing an unowned reference is a direct pointer access, so it does not depend on the number of objects.

Interview Connect

Understanding how unowned references work helps you reason about memory and performance in Swift, a skill valuable in many coding situations.

Self-Check

"What if we changed the unowned reference to a weak reference? How would the time complexity change?"