Destructuring patterns in Rust - Time & Space Complexity

Time Complexity: Destructuring patterns

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code with destructuring patterns changes as the input grows.

Specifically, we ask: how does the cost of breaking apart data with destructuring grow with input size?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn sum_points(points: &[(i32, i32)]) -> i32 {
    let mut total = 0;
    for &(x, y) in points {
        total += x + y;
    }
    total
}
    

This code sums all the x and y values from a list of point pairs using destructuring in the loop.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each point and destructuring the tuple into x and y.
• How many times: Once for each point in the input list.

How Execution Grows With Input

As the number of points grows, the code does more work by repeating the sum for each point.

Input Size (n)	Approx. Operations
10	About 10 sums and destructures
100	About 100 sums and destructures
1000	About 1000 sums and destructures

Pattern observation: The work grows directly with the number of points, so doubling points doubles work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of points.

Common Mistake

[X] Wrong: "Destructuring makes the code slower because it adds extra steps inside the loop."

[OK] Correct: Destructuring is just a way to name parts of the data and happens as part of the loop step, so it does not add extra loops or nested work.

Interview Connect

Understanding how destructuring affects time helps you explain your code clearly and shows you know how data access scales with input size.

Self-Check

"What if we changed the input to a nested list of points instead of a flat list? How would the time complexity change?"