Dictionary creation and access in Swift - Time & Space Complexity

Time Complexity: Dictionary creation and access

O(1)

Understanding Time Complexity

When we create and access dictionaries, it is important to know how the time to do these actions changes as the dictionary grows.

We want to understand how fast or slow these operations become when the dictionary has more items.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

var ages: [String: Int] = [:]

// Adding items
ages["Alice"] = 30
ages["Bob"] = 25
ages["Charlie"] = 35

// Accessing an item
let aliceAge = ages["Alice"]

This code creates a dictionary, adds three entries, and then accesses one entry by its key.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding or accessing a single key-value pair in the dictionary.
• How many times: Each add or access happens once per key; no loops or repeated traversals here.

How Execution Grows With Input

Adding or looking up a key in a dictionary takes about the same time no matter how many items are inside.

Input Size (n)	Approx. Operations
10	About 1 operation per add or access
100	Still about 1 operation per add or access
1000	Still about 1 operation per add or access

Pattern observation: The time to add or access does not grow much as the dictionary gets bigger.

Final Time Complexity

Time Complexity: O(1)

This means adding or accessing a value in a dictionary takes about the same short time no matter how many items are stored.

Common Mistake

[X] Wrong: "Accessing a dictionary item takes longer as the dictionary gets bigger because it searches through all items."

[OK] Correct: Dictionaries use a special method to jump directly to the item, so they don't check every entry one by one.

Interview Connect

Understanding dictionary time complexity helps you explain why certain data structures are fast and efficient, a useful skill in many coding discussions.

Self-Check

"What if we tried to find a value by searching through all keys instead of using the dictionary's direct access? How would the time complexity change?"